Merge branch 'develop'

This extends the compressed output vector's lifetime, as we issue an
asynchronous write operation that only receives a non-owning buffer to
the compressed data.

When the compressed output vector then goes out of scope, its destructor
is called and the data gets (potentially) destroyed. If the asynchronous
write happens afterwards, it's accessing data that is no longer there.

This is the reason for race conditions --- well, for undefined behavior
in general, but it manifests in the routed _sometimes_ not responding at
all.

The fix works like this: keep the compressed output associated with a
connection. Connections inherit from `std::enable_shared_from_this` and
issues a `shared_from_this()` call, passing a `std::shared_ptr` to the
asynchronous write function, thus extending their lifetime.

Connecitons thus manage their lifetime by themselves, extending it when
needed (and of course via the `std::shared_pointers` pointing to it).

Buffer's non owning property, from the `async_write` documentation:

> One or more buffers containing the data to be written. Although
> the buffers object may be copied as necessary, ownership of the
> underlying memory blocks is retained by the caller, which must
> guarantee that they remain valid until the handler is called.

Reference:

- http://www.boost.org/doc/libs/1_59_0/doc/html/boost_asio/reference/async_write/overload1.html

.gitignore

@@ -1,3 +1,7 @@
+# pre compiled dependencies #
+#############################
+osrm-deps
+
 # Compiled source #
 ###################
 *.com

.travis.yml

@@ -7,7 +7,7 @@ install:
  - sudo apt-add-repository -y ppa:ubuntu-toolchain-r/test
  - sudo add-apt-repository -y ppa:boost-latest/ppa
  - sudo apt-get update >/dev/null
- - sudo apt-get -q install protobuf-compiler libprotoc-dev libprotobuf7 libprotobuf-dev libbz2-dev libstxxl-dev libstxxl1 libxml2-dev libzip-dev lua5.1 liblua5.1-0-dev rubygems libtbb-dev
+ - sudo apt-get -q install libbz2-dev libstxxl-dev libstxxl1 libxml2-dev libzip-dev lua5.1 liblua5.1-0-dev rubygems libtbb-dev
  - sudo apt-get -q install g++-4.8
  - sudo apt-get install libboost1.54-all-dev
  - sudo apt-get install libgdal-dev
@@ -17,8 +17,6 @@ install:
  - curl -s https://gist.githubusercontent.com/DennisOSRM/803a64a9178ec375069f/raw/ | sudo bash
  # cmake
  - curl -s https://gist.githubusercontent.com/DennisOSRM/5fad9bee5c7f09fd7fc9/raw/ | sudo bash
- # osmpbf library
- - curl -s https://gist.githubusercontent.com/DennisOSRM/13b1b4fe38a57ead850e/raw/install_osmpbf.sh | sudo bash
 before_script:
  - rvm use 1.9.3
  - gem install bundler
@@ -30,6 +28,7 @@ script:
  - make
  - make tests
  - make benchmarks
+ - ./algorithm-tests
  - ./datastructure-tests
  - cd ..
  - cucumber -p verify
@@ -58,7 +57,7 @@ notifications:
   skip_join: false
 
   recipients:
-    - dennis@mapbox.com
+    - patrick@mapbox.com
   email:
     on_success: change
     on_failure: always

CMakeLists.txt

@@ -51,10 +51,11 @@ configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/util/git_sha.cpp
 )
 file(GLOB ExtractorGlob extractor/*.cpp)
-file(GLOB ImporterGlob data_structures/import_edge.cpp data_structures/external_memory_node.cpp)
+file(GLOB ImporterGlob data_structures/import_edge.cpp data_structures/external_memory_node.cpp data_structures/raster_source.cpp)
 add_library(IMPORT OBJECT ${ImporterGlob})
 add_library(LOGGER OBJECT util/simple_logger.cpp)
 add_library(PHANTOMNODE OBJECT data_structures/phantom_node.cpp)
+add_library(RASTERSOURCE OBJECT data_structures/raster_source.cpp)
 add_library(EXCEPTION OBJECT util/osrm_exception.cpp)
 add_library(MERCATOR OBJECT util/mercator.cpp)
 add_library(ANGLE OBJECT util/compute_angle.cpp)
@@ -63,21 +64,22 @@ set(ExtractorSources extract.cpp ${ExtractorGlob})
 add_executable(osrm-extract ${ExtractorSources} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
 
 add_library(RESTRICTION OBJECT data_structures/restriction_map.cpp)
+add_library(COMPRESSEDEDGE OBJECT data_structures/compressed_edge_container.cpp)
+add_library(GRAPHCOMPRESSOR OBJECT algorithms/graph_compressor.cpp)
 
 file(GLOB PrepareGlob contractor/*.cpp data_structures/hilbert_value.cpp {RestrictionMapGlob})
 set(PrepareSources prepare.cpp ${PrepareGlob})
-add_executable(osrm-prepare ${PrepareSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
+add_executable(osrm-prepare ${PrepareSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR>)
 
 file(GLOB ServerGlob server/*.cpp)
 file(GLOB DescriptorGlob descriptors/*.cpp)
 file(GLOB DatastructureGlob data_structures/search_engine_data.cpp data_structures/route_parameters.cpp util/bearing.cpp)
-list(REMOVE_ITEM DatastructureGlob data_structures/Coordinate.cpp)
-file(GLOB CoordinateGlob data_structures/coordinate*.cpp)
-file(GLOB AlgorithmGlob algorithms/*.cpp)
+file(GLOB CoordinateGlob data_structures/coordinate.cpp algorithms/coordinate_calculation.cpp)
+file(GLOB AlgorithmGlob algorithms/polyline_compressor.cpp algorithms/polyline_formatter.cpp algorithms/douglas_peucker.cpp)
 file(GLOB HttpGlob server/http/*.cpp)
 file(GLOB LibOSRMGlob library/*.cpp)
 file(GLOB DataStructureTestsGlob unit_tests/data_structures/*.cpp data_structures/hilbert_value.cpp)
-file(GLOB AlgorithmTestsGlob unit_tests/algorithms/*.cpp)
+file(GLOB AlgorithmTestsGlob unit_tests/algorithms/*.cpp algorithms/graph_compressor.cpp)
 
 set(
   OSRMSources
@@ -90,7 +92,7 @@ set(
 
 add_library(COORDINATE OBJECT ${CoordinateGlob})
 add_library(GITDESCRIPTION OBJECT util/git_sha.cpp)
-add_library(OSRM ${OSRMSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
+add_library(OSRM ${OSRMSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:IMPORT>)
 
 add_library(FINGERPRINT OBJECT util/fingerprint.cpp)
 add_dependencies(FINGERPRINT FingerPrintConfigure)
@@ -101,8 +103,8 @@ add_executable(osrm-routed routed.cpp ${ServerGlob} $<TARGET_OBJECTS:EXCEPTION>)
 add_executable(osrm-datastore datastore.cpp $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
 
 # Unit tests
-add_executable(datastructure-tests EXCLUDE_FROM_ALL unit_tests/datastructure_tests.cpp ${DataStructureTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
-add_executable(algorithm-tests EXCLUDE_FROM_ALL unit_tests/algorithm_tests.cpp ${AlgorithmTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION>)
+add_executable(datastructure-tests EXCLUDE_FROM_ALL unit_tests/datastructure_tests.cpp ${DataStructureTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:RASTERSOURCE>)
+add_executable(algorithm-tests EXCLUDE_FROM_ALL unit_tests/algorithm_tests.cpp ${AlgorithmTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:COMPRESSEDEDGE>)
 
 # Benchmarks
 add_executable(rtree-bench EXCLUDE_FROM_ALL benchmarks/static_rtree.cpp $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
@@ -280,16 +282,6 @@ if(OPENMP_FOUND)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
 endif()
 
-find_package(OSMPBF REQUIRED)
-include_directories(${OSMPBF_INCLUDE_DIR})
-target_link_libraries(osrm-extract ${OSMPBF_LIBRARY})
-target_link_libraries(osrm-prepare ${OSMPBF_LIBRARY})
-
-find_package(Protobuf REQUIRED)
-include_directories(${PROTOBUF_INCLUDE_DIRS})
-target_link_libraries(osrm-extract ${PROTOBUF_LIBRARY})
-target_link_libraries(osrm-prepare ${PROTOBUF_LIBRARY})
-
 find_package(BZip2 REQUIRED)
 include_directories(${BZIP_INCLUDE_DIRS})
 target_link_libraries(osrm-extract ${BZIP2_LIBRARIES})
@@ -328,12 +320,10 @@ if(WITH_TOOLS OR BUILD_TOOLS)
   if(UNIX AND NOT APPLE)
     target_link_libraries(osrm-unlock-all rt)
   endif()
-  add_executable(osrm-check-hsgr tools/check-hsgr.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER>)
-  target_link_libraries(osrm-check-hsgr ${Boost_LIBRARIES})
+  add_executable(osrm-check-hsgr tools/check-hsgr.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:IMPORT>)
+  target_link_libraries(osrm-check-hsgr ${Boost_LIBRARIES} ${TBB_LIBRARIES})
   add_executable(osrm-springclean tools/springclean.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:EXCEPTION>)
   target_link_libraries(osrm-springclean ${Boost_LIBRARIES})
-  add_executable(osrm-graph-compare tools/graph_compare.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
-  target_link_libraries(osrm-graph-compare ${Boost_LIBRARIES} ${TBB_LIBRARIES})
 
   install(TARGETS osrm-cli DESTINATION bin)
   install(TARGETS osrm-io-benchmark DESTINATION bin)

Gemfile.lock

@@ -2,22 +2,27 @@ GEM
   remote: http://rubygems.org/
   specs:
     builder (3.2.2)
-    cucumber (1.3.8)
+    cucumber (2.0.0)
       builder (>= 2.1.2)
+      cucumber-core (~> 1.1.3)
       diff-lcs (>= 1.1.3)
-      gherkin (~> 2.12.1)
+      gherkin (~> 2.12)
       multi_json (>= 1.7.5, < 2.0)
-      multi_test (>= 0.0.2)
-    diff-lcs (1.2.4)
-    gherkin (2.12.1)
+      multi_test (>= 0.1.2)
+    cucumber-core (1.1.3)
+      gherkin (~> 2.12.0)
+    diff-lcs (1.2.5)
+    gherkin (2.12.2)
       multi_json (~> 1.3)
-    multi_json (1.8.0)
-    multi_test (0.0.2)
+    multi_json (1.11.0)
+    multi_test (0.1.2)
     osmlib-base (0.1.4)
-    rake (10.1.0)
-    rspec-expectations (2.14.3)
-      diff-lcs (>= 1.1.3, < 2.0)
-    sys-proctable (0.9.3)
+    rake (10.4.2)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    sys-proctable (0.9.8)
 
 PLATFORMS
   ruby

README.md

@@ -1,12 +1,25 @@
-# Readme
+## About
 
-For instructions on how to compile and run OSRM, please consult the Wiki at
+The Open Source Routing Machine is a high performance routing engine written in C++11 designed to run on OpenStreetMap data.
 
-https://github.com/Project-OSRM/osrm-backend/wiki
+## Current build status
 
-or use our free and daily updated online service at
+| build config |  branch | status |
+|:-------------|:--------|:------------|
+| Linux        | master  | [![Build Status](https://travis-ci.org/Project-OSRM/osrm-backend.png?branch=master)](https://travis-ci.org/Project-OSRM/osrm-backend) |
+| Linux        | develop | [![Build Status](https://travis-ci.org/Project-OSRM/osrm-backend.png?branch=develop)](https://travis-ci.org/Project-OSRM/osrm-backend) |
+| Windows      | master/develop | [![Build status](https://ci.appveyor.com/api/projects/status/4iuo3s9gxprmcjjh)](https://ci.appveyor.com/project/DennisOSRM/osrm-backend) |
+| LUAbind fork | master  | [![Build Status](https://travis-ci.org/DennisOSRM/luabind.png?branch=master)](https://travis-ci.org/DennisOSRM/luabind) |
 
-http://map.project-osrm.org
+## Building
+
+For instructions on how to [build](https://github.com/Project-OSRM/osrm-backend/wiki/Building-OSRM) and [run OSRM](https://github.com/Project-OSRM/osrm-backend/wiki/Running-OSRM), please consult [the Wiki](https://github.com/Project-OSRM/osrm-backend/wiki).
+
+To quickly try OSRM use our [free and daily updated online service](http://map.project-osrm.org)
+
+## Documentation
+
+See the Wiki's [server API documentation](https://github.com/Project-OSRM/osrm-backend/wiki/Server-api) as well as the [library API documentation](https://github.com/Project-OSRM/osrm-backend/wiki/Library-api)
 
 ## References in publications
 
@@ -31,11 +44,3 @@ When using the code in a (scientific) publication, please cite
 }
 ```
 
-## Current build status
-
-| build config |  branch | status |
-|:-------------|:--------|:------------|
-| Linux        | master  | [![Build Status](https://travis-ci.org/Project-OSRM/osrm-backend.png?branch=master)](https://travis-ci.org/DennisOSRM/Project-OSRM) |
-| Linux        | develop | [![Build Status](https://travis-ci.org/Project-OSRM/osrm-backend.png?branch=develop)](https://travis-ci.org/DennisOSRM/Project-OSRM) |
-| Windows      | master/develop | [![Build status](https://ci.appveyor.com/api/projects/status/4iuo3s9gxprmcjjh)](https://ci.appveyor.com/project/DennisOSRM/osrm-backend) |
-| LUAbind fork | master  | [![Build Status](https://travis-ci.org/DennisOSRM/luabind.png?branch=master)](https://travis-ci.org/DennisOSRM/luabind) |

algorithms/bayes_classifier.hpp

@@ -31,6 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <cmath>
 
 #include <vector>
+#include <utility>
 
 struct NormalDistribution
 {
@@ -80,11 +81,11 @@ class BayesClassifier
     };
     using ClassificationT = std::pair<ClassLabel, double>;
 
-    BayesClassifier(const PositiveDistributionT &positive_distribution,
-                    const NegativeDistributionT &negative_distribution,
+    BayesClassifier(PositiveDistributionT positive_distribution,
+                    NegativeDistributionT negative_distribution,
                     const double positive_apriori_probability)
-        : positive_distribution(positive_distribution),
-          negative_distribution(negative_distribution),
+        : positive_distribution(std::move(positive_distribution)),
+          negative_distribution(std::move(negative_distribution)),
           positive_apriori_probability(positive_apriori_probability),
           negative_apriori_probability(1. - positive_apriori_probability)
     {

algorithms/coordinate_calculation.cpp

@@ -46,7 +46,10 @@ constexpr static const float RAD = 0.017453292519943295769236907684886f;
 constexpr static const float earth_radius = 6372797.560856f;
 }
 
-double coordinate_calculation::great_circle_distance(const int lat1,
+namespace coordinate_calculation
+{
+
+double great_circle_distance(const int lat1,
                                                      const int lon1,
                                                      const int lat2,
                                                      const int lon2)
@@ -74,21 +77,21 @@ double coordinate_calculation::great_circle_distance(const int lat1,
     return earth_radius * cHarv;
 }
 
-double coordinate_calculation::great_circle_distance(const FixedPointCoordinate &coordinate_1,
+double great_circle_distance(const FixedPointCoordinate &coordinate_1,
                                                      const FixedPointCoordinate &coordinate_2)
 {
     return great_circle_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
                                  coordinate_2.lon);
 }
 
-float coordinate_calculation::euclidean_distance(const FixedPointCoordinate &coordinate_1,
+float euclidean_distance(const FixedPointCoordinate &coordinate_1,
                                                  const FixedPointCoordinate &coordinate_2)
 {
     return euclidean_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
                               coordinate_2.lon);
 }
 
-float coordinate_calculation::euclidean_distance(const int lat1,
+float euclidean_distance(const int lat1,
                                                  const int lon1,
                                                  const int lat2,
                                                  const int lon2)
@@ -108,7 +111,7 @@ float coordinate_calculation::euclidean_distance(const int lat1,
     return std::hypot(x_value, y_value) * earth_radius;
 }
 
-float coordinate_calculation::perpendicular_distance(const FixedPointCoordinate &source_coordinate,
+float perpendicular_distance(const FixedPointCoordinate &source_coordinate,
                                                      const FixedPointCoordinate &target_coordinate,
                                                      const FixedPointCoordinate &query_location)
 {
@@ -119,7 +122,7 @@ float coordinate_calculation::perpendicular_distance(const FixedPointCoordinate
                                   nearest_location, ratio);
 }
 
-float coordinate_calculation::perpendicular_distance(const FixedPointCoordinate &segment_source,
+float perpendicular_distance(const FixedPointCoordinate &segment_source,
                                                      const FixedPointCoordinate &segment_target,
                                                      const FixedPointCoordinate &query_location,
                                                      FixedPointCoordinate &nearest_location,
@@ -132,7 +135,7 @@ float coordinate_calculation::perpendicular_distance(const FixedPointCoordinate
         nearest_location, ratio);
 }
 
-float coordinate_calculation::perpendicular_distance_from_projected_coordinate(
+float perpendicular_distance_from_projected_coordinate(
     const FixedPointCoordinate &source_coordinate,
     const FixedPointCoordinate &target_coordinate,
     const FixedPointCoordinate &query_location,
@@ -146,7 +149,7 @@ float coordinate_calculation::perpendicular_distance_from_projected_coordinate(
                                                             nearest_location, ratio);
 }
 
-float coordinate_calculation::perpendicular_distance_from_projected_coordinate(
+float perpendicular_distance_from_projected_coordinate(
     const FixedPointCoordinate &segment_source,
     const FixedPointCoordinate &segment_target,
     const FixedPointCoordinate &query_location,
@@ -221,29 +224,29 @@ float coordinate_calculation::perpendicular_distance_from_projected_coordinate(
     BOOST_ASSERT(nearest_location.is_valid());
 
     const float approximate_distance =
-        coordinate_calculation::euclidean_distance(query_location, nearest_location);
+        euclidean_distance(query_location, nearest_location);
     BOOST_ASSERT(0.f <= approximate_distance);
     return approximate_distance;
 }
 
-void coordinate_calculation::lat_or_lon_to_string(const int value, std::string &output)
+void lat_or_lon_to_string(const int value, std::string &output)
 {
     char buffer[12];
     buffer[11] = 0; // zero termination
     output = printInt<11, 6>(buffer, value);
 }
 
-float coordinate_calculation::deg_to_rad(const float degree)
+float deg_to_rad(const float degree)
 {
     return degree * (static_cast<float>(M_PI) / 180.f);
 }
 
-float coordinate_calculation::rad_to_deg(const float radian)
+float rad_to_deg(const float radian)
 {
     return radian * (180.f * static_cast<float>(M_1_PI));
 }
 
-float coordinate_calculation::bearing(const FixedPointCoordinate &first_coordinate,
+float bearing(const FixedPointCoordinate &first_coordinate,
                                       const FixedPointCoordinate &second_coordinate)
 {
     const float lon_diff =
@@ -266,3 +269,5 @@ float coordinate_calculation::bearing(const FixedPointCoordinate &first_coordina
     }
     return result;
 }
+
+}

algorithms/coordinate_calculation.hpp

@@ -33,38 +33,38 @@ struct FixedPointCoordinate;
 #include <string>
 #include <utility>
 
-struct coordinate_calculation
+namespace coordinate_calculation
 {
-    static double
+    double
     great_circle_distance(const int lat1, const int lon1, const int lat2, const int lon2);
 
-    static double great_circle_distance(const FixedPointCoordinate &first_coordinate,
-                                        const FixedPointCoordinate &second_coordinate);
+    double great_circle_distance(const FixedPointCoordinate &first_coordinate,
+                                 const FixedPointCoordinate &second_coordinate);
 
-    static float euclidean_distance(const FixedPointCoordinate &first_coordinate,
-                                    const FixedPointCoordinate &second_coordinate);
+    float euclidean_distance(const FixedPointCoordinate &first_coordinate,
+                             const FixedPointCoordinate &second_coordinate);
 
-    static float euclidean_distance(const int lat1, const int lon1, const int lat2, const int lon2);
+    float euclidean_distance(const int lat1, const int lon1, const int lat2, const int lon2);
 
-    static void lat_or_lon_to_string(const int value, std::string &output);
+    void lat_or_lon_to_string(const int value, std::string &output);
 
-    static float perpendicular_distance(const FixedPointCoordinate &segment_source,
-                                        const FixedPointCoordinate &segment_target,
-                                        const FixedPointCoordinate &query_location);
+    float perpendicular_distance(const FixedPointCoordinate &segment_source,
+                                 const FixedPointCoordinate &segment_target,
+                                 const FixedPointCoordinate &query_location);
 
-    static float perpendicular_distance(const FixedPointCoordinate &segment_source,
-                                        const FixedPointCoordinate &segment_target,
-                                        const FixedPointCoordinate &query_location,
-                                        FixedPointCoordinate &nearest_location,
-                                        float &ratio);
+    float perpendicular_distance(const FixedPointCoordinate &segment_source,
+                                 const FixedPointCoordinate &segment_target,
+                                 const FixedPointCoordinate &query_location,
+                                 FixedPointCoordinate &nearest_location,
+                                 float &ratio);
 
-    static float perpendicular_distance_from_projected_coordinate(
+    float perpendicular_distance_from_projected_coordinate(
         const FixedPointCoordinate &segment_source,
         const FixedPointCoordinate &segment_target,
         const FixedPointCoordinate &query_location,
         const std::pair<double, double> &projected_coordinate);
 
-    static float perpendicular_distance_from_projected_coordinate(
+    float perpendicular_distance_from_projected_coordinate(
         const FixedPointCoordinate &segment_source,
         const FixedPointCoordinate &segment_target,
         const FixedPointCoordinate &query_location,
@@ -72,11 +72,11 @@ struct coordinate_calculation
         FixedPointCoordinate &nearest_location,
         float &ratio);
 
-    static float deg_to_rad(const float degree);
-    static float rad_to_deg(const float radian);
+    float deg_to_rad(const float degree);
+    float rad_to_deg(const float radian);
 
-    static float bearing(const FixedPointCoordinate &first_coordinate,
-                         const FixedPointCoordinate &second_coordinate);
-};
+    float bearing(const FixedPointCoordinate &first_coordinate,
+                  const FixedPointCoordinate &second_coordinate);
+}
 
 #endif // COORDINATE_CALCULATION

algorithms/douglas_peucker.cpp

@@ -99,8 +99,8 @@ void DouglasPeucker::Run(RandomAccessIt begin, RandomAccessIt end, const unsigne
 
     {
         BOOST_ASSERT_MSG(zoom_level < DOUGLAS_PEUCKER_THRESHOLDS.size(), "unsupported zoom level");
-        RandomAccessIt left_border = begin;
-        RandomAccessIt right_border = std::next(begin);
+        auto left_border = begin;
+        auto right_border = std::next(begin);
         // Sweep over array and identify those ranges that need to be checked
         do
         {

algorithms/graph_compressor.cpp

@@ -0,0 +1,188 @@
+#include "graph_compressor.hpp"
+
+#include "../data_structures/compressed_edge_container.hpp"
+#include "../data_structures/dynamic_graph.hpp"
+#include "../data_structures/node_based_graph.hpp"
+#include "../data_structures/restriction_map.hpp"
+#include "../data_structures/percent.hpp"
+
+#include "../util/simple_logger.hpp"
+
+GraphCompressor::GraphCompressor(SpeedProfileProperties speed_profile)
+    : speed_profile(std::move(speed_profile))
+{
+}
+
+
+void GraphCompressor::Compress(const std::unordered_set<NodeID>& barrier_nodes,
+                               const std::unordered_set<NodeID>& traffic_lights,
+                               RestrictionMap& restriction_map,
+                               NodeBasedDynamicGraph& graph,
+                               CompressedEdgeContainer& geometry_compressor)
+{
+    const unsigned original_number_of_nodes = graph.GetNumberOfNodes();
+    const unsigned original_number_of_edges = graph.GetNumberOfEdges();
+
+    Percent progress(original_number_of_nodes);
+
+    for (const NodeID node_v : osrm::irange(0u, original_number_of_nodes))
+    {
+        progress.printStatus(node_v);
+
+        // only contract degree 2 vertices
+        if (2 != graph.GetOutDegree(node_v))
+        {
+            continue;
+        }
+
+        // don't contract barrier node
+        if (barrier_nodes.end() != barrier_nodes.find(node_v))
+        {
+            continue;
+        }
+
+        // check if v is a via node for a turn restriction, i.e. a 'directed' barrier node
+        if (restriction_map.IsViaNode(node_v))
+        {
+            continue;
+        }
+
+        //    reverse_e2   forward_e2
+        // u <---------- v -----------> w
+        //    ----------> <-----------
+        //    forward_e1   reverse_e1
+        //
+        // Will be compressed to:
+        //
+        //    reverse_e1
+        // u <---------- w
+        //    ---------->
+        //    forward_e1
+        //
+        // If the edges are compatible.
+
+        const bool reverse_edge_order = graph.GetEdgeData(graph.BeginEdges(node_v)).reversed;
+        const EdgeID forward_e2 = graph.BeginEdges(node_v) + reverse_edge_order;
+        BOOST_ASSERT(SPECIAL_EDGEID != forward_e2);
+        BOOST_ASSERT(forward_e2 >= graph.BeginEdges(node_v) &&
+                     forward_e2 < graph.EndEdges(node_v));
+        const EdgeID reverse_e2 = graph.BeginEdges(node_v) + 1 - reverse_edge_order;
+        BOOST_ASSERT(SPECIAL_EDGEID != reverse_e2);
+        BOOST_ASSERT(reverse_e2 >= graph.BeginEdges(node_v) &&
+                     reverse_e2 < graph.EndEdges(node_v));
+
+        const EdgeData &fwd_edge_data2 = graph.GetEdgeData(forward_e2);
+        const EdgeData &rev_edge_data2 = graph.GetEdgeData(reverse_e2);
+
+        const NodeID node_w = graph.GetTarget(forward_e2);
+        BOOST_ASSERT(SPECIAL_NODEID != node_w);
+        BOOST_ASSERT(node_v != node_w);
+        const NodeID node_u = graph.GetTarget(reverse_e2);
+        BOOST_ASSERT(SPECIAL_NODEID != node_u);
+        BOOST_ASSERT(node_u != node_v);
+
+        const EdgeID forward_e1 = graph.FindEdge(node_u, node_v);
+        BOOST_ASSERT(SPECIAL_EDGEID != forward_e1);
+        BOOST_ASSERT(node_v == graph.GetTarget(forward_e1));
+        const EdgeID reverse_e1 = graph.FindEdge(node_w, node_v);
+        BOOST_ASSERT(SPECIAL_EDGEID != reverse_e1);
+        BOOST_ASSERT(node_v == graph.GetTarget(reverse_e1));
+
+        const EdgeData &fwd_edge_data1 = graph.GetEdgeData(forward_e1);
+        const EdgeData &rev_edge_data1 = graph.GetEdgeData(reverse_e1);
+
+        if (graph.FindEdgeInEitherDirection(node_u, node_w) != SPECIAL_EDGEID)
+        {
+            continue;
+        }
+
+        // this case can happen if two ways with different names overlap
+        if (fwd_edge_data1.name_id != rev_edge_data1.name_id ||
+            fwd_edge_data2.name_id != rev_edge_data2.name_id)
+        {
+            continue;
+        }
+
+        if (fwd_edge_data1.IsCompatibleTo(fwd_edge_data2) && rev_edge_data1.IsCompatibleTo(rev_edge_data2))
+        {
+            BOOST_ASSERT(graph.GetEdgeData(forward_e1).name_id ==
+                         graph.GetEdgeData(reverse_e1).name_id);
+            BOOST_ASSERT(graph.GetEdgeData(forward_e2).name_id ==
+                         graph.GetEdgeData(reverse_e2).name_id);
+
+            // Get distances before graph is modified
+            const int forward_weight1 = graph.GetEdgeData(forward_e1).distance;
+            const int forward_weight2 = graph.GetEdgeData(forward_e2).distance;
+
+            BOOST_ASSERT(0 != forward_weight1);
+            BOOST_ASSERT(0 != forward_weight2);
+
+            const int reverse_weight1 = graph.GetEdgeData(reverse_e1).distance;
+            const int reverse_weight2 = graph.GetEdgeData(reverse_e2).distance;
+
+            BOOST_ASSERT(0 != reverse_weight1);
+            BOOST_ASSERT(0 != reverse_weight2);
+
+            const bool has_node_penalty = traffic_lights.find(node_v) != traffic_lights.end();
+
+            // add weight of e2's to e1
+            graph.GetEdgeData(forward_e1).distance += fwd_edge_data2.distance;
+            graph.GetEdgeData(reverse_e1).distance += rev_edge_data2.distance;
+            if (has_node_penalty)
+            {
+                graph.GetEdgeData(forward_e1).distance +=
+                    speed_profile.traffic_signal_penalty;
+                graph.GetEdgeData(reverse_e1).distance +=
+                    speed_profile.traffic_signal_penalty;
+            }
+
+            // extend e1's to targets of e2's
+            graph.SetTarget(forward_e1, node_w);
+            graph.SetTarget(reverse_e1, node_u);
+
+            // remove e2's (if bidir, otherwise only one)
+            graph.DeleteEdge(node_v, forward_e2);
+            graph.DeleteEdge(node_v, reverse_e2);
+
+            // update any involved turn restrictions
+            restriction_map.FixupStartingTurnRestriction(node_u, node_v, node_w);
+            restriction_map.FixupArrivingTurnRestriction(node_u, node_v, node_w, graph);
+
+            restriction_map.FixupStartingTurnRestriction(node_w, node_v, node_u);
+            restriction_map.FixupArrivingTurnRestriction(node_w, node_v, node_u, graph);
+
+            // store compressed geometry in container
+            geometry_compressor.CompressEdge(
+                forward_e1, forward_e2, node_v, node_w,
+                forward_weight1 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0),
+                forward_weight2);
+            geometry_compressor.CompressEdge(
+                reverse_e1, reverse_e2, node_v, node_u, reverse_weight1,
+                reverse_weight2 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0));
+        }
+    }
+
+    PrintStatistics(original_number_of_nodes, original_number_of_edges, graph);
+}
+
+void GraphCompressor::PrintStatistics(unsigned original_number_of_nodes,
+                                      unsigned original_number_of_edges,
+                                      const NodeBasedDynamicGraph& graph) const
+{
+
+    unsigned new_node_count = 0;
+    unsigned new_edge_count = 0;
+
+    for (const auto i : osrm::irange(0u, graph.GetNumberOfNodes()))
+    {
+        if (graph.GetOutDegree(i) > 0)
+        {
+            ++new_node_count;
+            new_edge_count += (graph.EndEdges(i) - graph.BeginEdges(i));
+        }
+    }
+    SimpleLogger().Write() << "Node compression ratio: "
+                           << new_node_count / (double)original_number_of_nodes;
+    SimpleLogger().Write() << "Edge compression ratio: "
+                           << new_edge_count / (double)original_number_of_edges;
+}

algorithms/graph_compressor.hpp

@@ -0,0 +1,62 @@
+/*
+
+Copyright (c) 2014, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+#ifndef GEOMETRY_COMPRESSOR_HPP
+#define GEOMETRY_COMPRESSOR_HPP
+
+#include "../typedefs.h"
+
+#include "../contractor/speed_profile.hpp"
+#include "../data_structures/node_based_graph.hpp"
+
+#include <memory>
+#include <unordered_set>
+
+class CompressedEdgeContainer;
+class RestrictionMap;
+
+class GraphCompressor
+{
+    using EdgeData = NodeBasedDynamicGraph::EdgeData;
+
+public:
+  GraphCompressor(SpeedProfileProperties speed_profile);
+
+    void Compress(const std::unordered_set<NodeID>& barrier_nodes,
+                  const std::unordered_set<NodeID>& traffic_lights,
+                  RestrictionMap& restriction_map,
+                  NodeBasedDynamicGraph& graph,
+                  CompressedEdgeContainer& geometry_compressor);
+private:
+
+   void PrintStatistics(unsigned original_number_of_nodes,
+                        unsigned original_number_of_edges,
+                        const NodeBasedDynamicGraph& graph) const;
+
+    SpeedProfileProperties speed_profile;
+};
+
+#endif

algorithms/object_encoder.hpp

@@ -79,7 +79,7 @@ struct ObjectEncoder
             replaceAll(encoded, "-", "+");
             replaceAll(encoded, "_", "/");
 
-            std::copy(binary_t(encoded.begin()), binary_t(encoded.begin() + encoded.length() - 1),
+            std::copy(binary_t(encoded.begin()), binary_t(encoded.begin() + encoded.length()),
                       reinterpret_cast<char *>(&object));
         }
         catch (...)

algorithms/polyline_compressor.cpp

@@ -88,3 +88,41 @@ PolylineCompressor::get_encoded_string(const std::vector<SegmentInformation> &po
     }
     return encode_vector(delta_numbers);
 }
+
+std::vector<FixedPointCoordinate> PolylineCompressor::decode_string(const std::string &geometry_string) const
+{
+    std::vector<FixedPointCoordinate> new_coordinates;
+    int index = 0, len = geometry_string.size();
+    int lat = 0, lng = 0;
+  
+    while (index < len) 
+    {
+        int b, shift = 0, result = 0;
+        do 
+        {
+            b = geometry_string.at(index++) - 63;
+            result |= (b & 0x1f) << shift;
+            shift += 5;
+        } while (b >= 0x20);
+        int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
+        lat += dlat;
+
+        shift = 0;
+        result = 0;
+        do 
+        {
+            b = geometry_string.at(index++) - 63;
+            result |= (b & 0x1f) << shift;
+            shift += 5;
+        } while (b >= 0x20);
+        int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
+        lng += dlng;
+
+        FixedPointCoordinate p;
+        p.lat = COORDINATE_PRECISION * (((double) lat / 1E6));
+        p.lon = COORDINATE_PRECISION * (((double) lng / 1E6));
+        new_coordinates.push_back(p);
+    }
+
+    return new_coordinates;
+}

algorithms/polyline_compressor.hpp

@@ -30,6 +30,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct SegmentInformation;
 
+#include <osrm/coordinate.hpp>
+
 #include <string>
 #include <vector>
 
@@ -42,6 +44,8 @@ class PolylineCompressor
 
   public:
     std::string get_encoded_string(const std::vector<SegmentInformation> &polyline) const;
+    
+    std::vector<FixedPointCoordinate> decode_string(const std::string &geometry_string) const;
 };
 
 #endif /* POLYLINECOMPRESSOR_H_ */

algorithms/tarjan_scc.hpp

@@ -25,17 +25,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef TINY_COMPONENTS_HPP
-#define TINY_COMPONENTS_HPP
+#ifndef TARJAN_SCC_HPP
+#define TARJAN_SCC_HPP
 
 #include "../typedefs.h"
 #include "../data_structures/deallocating_vector.hpp"
 #include "../data_structures/import_edge.hpp"
 #include "../data_structures/query_node.hpp"
 #include "../data_structures/percent.hpp"
-#include "../data_structures/restriction.hpp"
-#include "../data_structures/restriction_map.hpp"
-#include "../data_structures/turn_instructions.hpp"
 
 #include "../util/integer_range.hpp"
 #include "../util/simple_logger.hpp"
@@ -43,17 +40,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../util/timing_util.hpp"
 
 #include <osrm/coordinate.hpp>
-
 #include <boost/assert.hpp>
-
-#include <tbb/parallel_sort.h>
-
 #include <cstdint>
 
 #include <memory>
+#include <algorithm>
+#include <climits>
 #include <stack>
-#include <unordered_map>
-#include <unordered_set>
 #include <vector>
 
 template <typename GraphT> class TarjanSCC
@@ -75,27 +68,21 @@ template <typename GraphT> class TarjanSCC
 
     std::vector<unsigned> components_index;
     std::vector<NodeID> component_size_vector;
-    std::shared_ptr<GraphT> m_node_based_graph;
-    std::unordered_set<NodeID> barrier_node_set;
-    RestrictionMap m_restriction_map;
+    std::shared_ptr<const GraphT> m_graph;
     std::size_t size_one_counter;
 
   public:
-    template <class ContainerT>
-    TarjanSCC(std::shared_ptr<GraphT> graph,
-              const RestrictionMap &restrictions,
-              const ContainerT &barrier_node_list)
-        : components_index(graph->GetNumberOfNodes(), SPECIAL_NODEID), m_node_based_graph(graph),
-          m_restriction_map(restrictions), size_one_counter(0)
+    TarjanSCC(std::shared_ptr<const GraphT> graph)
+        : components_index(graph->GetNumberOfNodes(), SPECIAL_NODEID), m_graph(graph),
+          size_one_counter(0)
     {
-        barrier_node_set.insert(std::begin(barrier_node_list), std::end(barrier_node_list));
-        BOOST_ASSERT(m_node_based_graph->GetNumberOfNodes() > 0);
+        BOOST_ASSERT(m_graph->GetNumberOfNodes() > 0);
     }
 
     void run()
     {
         TIMER_START(SCC_RUN);
-        const NodeID max_node_id = m_node_based_graph->GetNumberOfNodes();
+        const NodeID max_node_id = m_graph->GetNumberOfNodes();
 
         // The following is a hack to distinguish between stuff that happens
         // before the recursive call and stuff that happens after
@@ -140,30 +127,9 @@ template <typename GraphT> class TarjanSCC
                     tarjan_node_list[v].on_stack = true;
                     ++index;
 
-                    const NodeID to_node_of_only_restriction =
-                        m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v);
-
-                    for (const auto current_edge : m_node_based_graph->GetAdjacentEdgeRange(v))
+                    for (const auto current_edge : m_graph->GetAdjacentEdgeRange(v))
                     {
-                        const auto vprime = m_node_based_graph->GetTarget(current_edge);
-
-                        // Traverse outgoing edges
-                        if (barrier_node_set.find(v) != barrier_node_set.end() && u != vprime)
-                        {
-                            // continue;
-                        }
-
-                        if (to_node_of_only_restriction != std::numeric_limits<unsigned>::max() &&
-                            vprime == to_node_of_only_restriction)
-                        {
-                            // At an only_-restriction but not at the right turn
-                            // continue;
-                        }
-
-                        if (m_restriction_map.CheckIfTurnIsRestricted(u, v, vprime))
-                        {
-                            // continue;
-                        }
+                        const auto vprime = m_graph->GetTarget(current_edge);
 
                         if (SPECIAL_NODEID == tarjan_node_list[vprime].index)
                         {
@@ -182,9 +148,8 @@ template <typename GraphT> class TarjanSCC
                 else
                 {
                     processing_node_before_recursion[v] = true;
-                    tarjan_node_list[currentFrame.parent].low_link =
-                        std::min(tarjan_node_list[currentFrame.parent].low_link,
-                                 tarjan_node_list[v].low_link);
+                    tarjan_node_list[u].low_link =
+                        std::min(tarjan_node_list[u].low_link, tarjan_node_list[v].low_link);
                     // after recursion, lets do cycle checking
                     // Check if we found a cycle. This is the bottom part of the recursion
                     if (tarjan_node_list[v].low_link == tarjan_node_list[v].index)
@@ -228,12 +193,12 @@ template <typename GraphT> class TarjanSCC
 
     std::size_t get_size_one_count() const { return size_one_counter; }
 
-    unsigned get_component_size(const NodeID node) const
+    unsigned get_component_size(const unsigned component_id) const
     {
-        return component_size_vector[components_index[node]];
+        return component_size_vector[component_id];
     }
 
     unsigned get_component_id(const NodeID node) const { return components_index[node]; }
 };
 
-#endif /* TINY_COMPONENTS_HPP */
+#endif /* TARJAN_SCC_HPP */

algorithms/trip_brute_force.hpp

@@ -0,0 +1,106 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRIP_BRUTE_FORCE_HPP
+#define TRIP_BRUTE_FORCE_HPP
+
+#include "../data_structures/search_engine.hpp"
+#include "../util/dist_table_wrapper.hpp"
+#include "../util/simple_logger.hpp"
+
+#include <osrm/json_container.hpp>
+
+#include <cstdlib>
+#include <algorithm>
+#include <string>
+#include <iterator>
+#include <vector>
+#include <limits>
+
+namespace osrm
+{
+namespace trip
+{
+
+// computes the distance of a given permutation
+EdgeWeight ReturnDistance(const DistTableWrapper<EdgeWeight> &dist_table,
+                          const std::vector<NodeID> &location_order,
+                          const EdgeWeight min_route_dist,
+                          const std::size_t component_size)
+{
+    EdgeWeight route_dist = 0;
+    std::size_t i = 0;
+    while (i < location_order.size() && (route_dist < min_route_dist))
+    {
+        route_dist += dist_table(location_order[i], location_order[(i + 1) % component_size]);
+        BOOST_ASSERT_MSG(dist_table(location_order[i], location_order[(i + 1) % component_size]) !=
+                             INVALID_EDGE_WEIGHT,
+                         "invalid route found");
+        ++i;
+    }
+
+    return route_dist;
+}
+
+// computes the route by computing all permutations and selecting the shortest
+template <typename NodeIDIterator>
+std::vector<NodeID> BruteForceTrip(const NodeIDIterator start,
+                                   const NodeIDIterator end,
+                                   const std::size_t number_of_locations,
+                                   const DistTableWrapper<EdgeWeight> &dist_table)
+{
+    const auto component_size = std::distance(start, end);
+
+    std::vector<NodeID> perm(start, end);
+    std::vector<NodeID> route;
+    route.reserve(component_size);
+
+    EdgeWeight min_route_dist = INVALID_EDGE_WEIGHT;
+
+    // check length of all possible permutation of the component ids
+
+    BOOST_ASSERT_MSG(perm.size() > 0, "no permutation given");
+    BOOST_ASSERT_MSG(*(std::max_element(std::begin(perm), std::end(perm))) < number_of_locations,
+                     "invalid node id");
+    BOOST_ASSERT_MSG(*(std::min_element(std::begin(perm), std::end(perm))) >= 0, "invalid node id");
+
+    do
+    {
+        const auto new_distance = ReturnDistance(dist_table, perm, min_route_dist, component_size);
+        if (new_distance <= min_route_dist)
+        {
+            min_route_dist = new_distance;
+            route = perm;
+        }
+    } while (std::next_permutation(std::begin(perm), std::end(perm)));
+
+    return route;
+}
+
+} // end namespace trip
+} // end namespace osrm
+#endif // TRIP_BRUTE_FORCE_HPP

algorithms/trip_farthest_insertion.hpp

@@ -0,0 +1,215 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRIP_FARTHEST_INSERTION_HPP
+#define TRIP_FARTHEST_INSERTION_HPP
+
+#include "../data_structures/search_engine.hpp"
+#include "../util/dist_table_wrapper.hpp"
+
+#include <osrm/json_container.hpp>
+#include <boost/assert.hpp>
+
+#include <cstdlib>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <limits>
+
+namespace osrm
+{
+namespace trip
+{
+
+// given a route and a new location, find the best place of insertion and
+// check the distance of roundtrip when the new location is additionally visited
+using NodeIDIter = std::vector<NodeID>::iterator;
+std::pair<EdgeWeight, NodeIDIter>
+GetShortestRoundTrip(const NodeID new_loc,
+                     const DistTableWrapper<EdgeWeight> &dist_table,
+                     const std::size_t number_of_locations,
+                     std::vector<NodeID> &route)
+{
+
+    auto min_trip_distance = INVALID_EDGE_WEIGHT;
+    NodeIDIter next_insert_point_candidate;
+
+    // for all nodes in the current trip find the best insertion resulting in the shortest path
+    // assert min 2 nodes in route
+    const auto start = std::begin(route);
+    const auto end = std::end(route);
+    for (auto from_node = start; from_node != end; ++from_node)
+    {
+        auto to_node = std::next(from_node);
+        if (to_node == end)
+        {
+            to_node = start;
+        }
+
+        const auto dist_from = dist_table(*from_node, new_loc);
+        const auto dist_to = dist_table(new_loc, *to_node);
+        const auto trip_dist = dist_from + dist_to - dist_table(*from_node, *to_node);
+
+        BOOST_ASSERT_MSG(dist_from != INVALID_EDGE_WEIGHT, "distance has invalid edge weight");
+        BOOST_ASSERT_MSG(dist_to != INVALID_EDGE_WEIGHT, "distance has invalid edge weight");
+        BOOST_ASSERT_MSG(trip_dist >= 0, "previous trip was not minimal. something's wrong");
+
+        // from all possible insertions to the current trip, choose the shortest of all insertions
+        if (trip_dist < min_trip_distance)
+        {
+            min_trip_distance = trip_dist;
+            next_insert_point_candidate = to_node;
+        }
+    }
+    BOOST_ASSERT_MSG(min_trip_distance != INVALID_EDGE_WEIGHT, "trip has invalid edge weight");
+
+    return std::make_pair(min_trip_distance, next_insert_point_candidate);
+}
+
+template <typename NodeIDIterator>
+// given two initial start nodes, find a roundtrip route using the farthest insertion algorithm
+std::vector<NodeID> FindRoute(const std::size_t &number_of_locations,
+                              const std::size_t &component_size,
+                              const NodeIDIterator &start,
+                              const NodeIDIterator &end,
+                              const DistTableWrapper<EdgeWeight> &dist_table,
+                              const NodeID &start1,
+                              const NodeID &start2)
+{
+    BOOST_ASSERT_MSG(number_of_locations >= component_size,
+                     "component size bigger than total number of locations");
+
+    std::vector<NodeID> route;
+    route.reserve(number_of_locations);
+
+    // tracks which nodes have been already visited
+    std::vector<bool> visited(number_of_locations, false);
+
+    visited[start1] = true;
+    visited[start2] = true;
+    route.push_back(start1);
+    route.push_back(start2);
+
+    // add all other nodes missing (two nodes are already in the initial start trip)
+    for (std::size_t j = 2; j < component_size; ++j)
+    {
+
+        auto farthest_distance = 0;
+        auto next_node = -1;
+        NodeIDIter next_insert_point;
+
+        // find unvisited loc i that is the farthest away from all other visited locs
+        for (auto i = start; i != end; ++i)
+        {
+            // find the shortest distance from i to all visited nodes
+            if (!visited[*i])
+            {
+                const auto insert_candidate =
+                    GetShortestRoundTrip(*i, dist_table, number_of_locations, route);
+
+                BOOST_ASSERT_MSG(insert_candidate.first != INVALID_EDGE_WEIGHT,
+                                 "shortest round trip is invalid");
+
+                // add the location to the current trip such that it results in the shortest total
+                // tour
+                if (insert_candidate.first >= farthest_distance)
+                {
+                    farthest_distance = insert_candidate.first;
+                    next_node = *i;
+                    next_insert_point = insert_candidate.second;
+                }
+            }
+        }
+
+        BOOST_ASSERT_MSG(next_node >= 0, "next node to visit is invalid");
+
+        // mark as visited and insert node
+        visited[next_node] = true;
+        route.insert(next_insert_point, next_node);
+    }
+    return route;
+}
+
+template <typename NodeIDIterator>
+std::vector<NodeID> FarthestInsertionTrip(const NodeIDIterator &start,
+                                          const NodeIDIterator &end,
+                                          const std::size_t number_of_locations,
+                                          const DistTableWrapper<EdgeWeight> &dist_table)
+{
+    //////////////////////////////////////////////////////////////////////////////////////////////////
+    // START FARTHEST INSERTION HERE
+    // 1. start at a random round trip of 2 locations
+    // 2. find the location that is the farthest away from the visited locations and whose insertion
+    // will make the round trip the longest
+    // 3. add the found location to the current round trip such that round trip is the shortest
+    // 4. repeat 2-3 until all locations are visited
+    // 5. DONE!
+    //////////////////////////////////////////////////////////////////////////////////////////////////
+
+    const auto component_size = std::distance(start, end);
+    BOOST_ASSERT(component_size >= 0);
+
+    auto max_from = -1;
+    auto max_to = -1;
+
+    if (static_cast<std::size_t>(component_size) == number_of_locations)
+    {
+        // find the pair of location with the biggest distance and make the pair the initial start
+        // trip
+        const auto index = std::distance(
+            std::begin(dist_table), std::max_element(std::begin(dist_table), std::end(dist_table)));
+        max_from = index / number_of_locations;
+        max_to = index % number_of_locations;
+    }
+    else
+    {
+        auto max_dist = 0;
+        for (auto x = start; x != end; ++x)
+        {
+            for (auto y = start; y != end; ++y)
+            {
+                const auto xy_dist = dist_table(*x, *y);
+                if (xy_dist > max_dist)
+                {
+                    max_dist = xy_dist;
+                    max_from = *x;
+                    max_to = *y;
+                }
+            }
+        }
+    }
+    BOOST_ASSERT(max_from >= 0);
+    BOOST_ASSERT(max_to >= 0);
+    BOOST_ASSERT_MSG(static_cast<std::size_t>(max_from) < number_of_locations, "start node");
+    BOOST_ASSERT_MSG(static_cast<std::size_t>(max_to) < number_of_locations, "start node");
+    return FindRoute(number_of_locations, component_size, start, end, dist_table, max_from, max_to);
+}
+
+} // end namespace trip
+} // end namespace osrm
+
+#endif // TRIP_FARTHEST_INSERTION_HPP

algorithms/trip_nearest_neighbour.hpp

@@ -0,0 +1,122 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRIP_NEAREST_NEIGHBOUR_HPP
+#define TRIP_NEAREST_NEIGHBOUR_HPP
+
+#include "../data_structures/search_engine.hpp"
+#include "../util/simple_logger.hpp"
+#include "../util/dist_table_wrapper.hpp"
+
+#include <osrm/json_container.hpp>
+
+#include <cstdlib>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <limits>
+
+namespace osrm
+{
+namespace trip
+{
+template <typename NodeIDIterator>
+std::vector<NodeID> NearestNeighbourTrip(const NodeIDIterator &start,
+                                         const NodeIDIterator &end,
+                                         const std::size_t number_of_locations,
+                                         const DistTableWrapper<EdgeWeight> &dist_table)
+{
+    //////////////////////////////////////////////////////////////////////////////////////////////////
+    // START GREEDY NEAREST NEIGHBOUR HERE
+    // 1. grab a random location and mark as starting point
+    // 2. find the nearest unvisited neighbour, set it as the current location and mark as visited
+    // 3. repeat 2 until there is no unvisited location
+    // 4. return route back to starting point
+    // 5. compute route
+    // 6. repeat 1-5 with different starting points and choose iteration with shortest trip
+    // 7. DONE!
+    //////////////////////////////////////////////////////////////////////////////////////////////////
+    std::vector<NodeID> route;
+    route.reserve(number_of_locations);
+
+    const auto component_size = std::distance(start, end);
+    auto shortest_trip_distance = INVALID_EDGE_WEIGHT;
+
+    // ALWAYS START AT ANOTHER STARTING POINT
+    for (auto start_node = start; start_node != end; ++start_node)
+    {
+        NodeID curr_node = *start_node;
+
+        std::vector<NodeID> curr_route;
+        curr_route.reserve(component_size);
+        curr_route.push_back(*start_node);
+
+        // visited[i] indicates whether node i was already visited by the salesman
+        std::vector<bool> visited(number_of_locations, false);
+        visited[*start_node] = true;
+
+        // 3. REPEAT FOR EVERY UNVISITED NODE
+        EdgeWeight trip_dist = 0;
+        for (std::size_t via_point = 1; via_point < component_size; ++via_point)
+        {
+            EdgeWeight min_dist = INVALID_EDGE_WEIGHT;
+            NodeID min_id = SPECIAL_NODEID;
+
+            // 2. FIND NEAREST NEIGHBOUR
+            for (auto next = start; next != end; ++next)
+            {
+                const auto curr_dist = dist_table(curr_node, *next);
+                BOOST_ASSERT_MSG(curr_dist != INVALID_EDGE_WEIGHT, "invalid distance found");
+                if (!visited[*next] && curr_dist < min_dist)
+                {
+                    min_dist = curr_dist;
+                    min_id = *next;
+                }
+            }
+
+            BOOST_ASSERT_MSG(min_id != SPECIAL_NODEID, "no next node found");
+
+            visited[min_id] = true;
+            curr_route.push_back(min_id);
+            trip_dist += min_dist;
+            curr_node = min_id;
+        }
+
+        // check round trip with this starting point is shorter than the shortest round trip found
+        // till now
+        if (trip_dist < shortest_trip_distance)
+        {
+            shortest_trip_distance = trip_dist;
+            route = std::move(curr_route);
+        }
+    }
+    return route;
+}
+
+} // end namespace trip
+} // end namespace osrm
+#endif // TRIP_NEAREST_NEIGHBOUR_HPP

algorithms/trip_tabu_search.hpp

@@ -0,0 +1,64 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRIP_BRUTE_FORCE_HPP
+#define TRIP_BRUTE_FORCE_HPP
+
+#include "../data_structures/search_engine.hpp"
+#include "../util/simple_logger.hpp"
+
+#include <osrm/json_container.hpp>
+
+#include <cstdlib>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <limits>
+
+namespace osrm
+{
+namespace trip
+{
+
+// todo: yet to be implemented
+void TabuSearchTrip(std::vector<unsigned> &location,
+                    const PhantomNodeArray &phantom_node_vector,
+                    const std::vector<EdgeWeight> &dist_table,
+                    InternalRouteResult &min_route,
+                    std::vector<int> &min_loc_permutation)
+{
+}
+
+void TabuSearchTrip(const PhantomNodeArray &phantom_node_vector,
+                    const std::vector<EdgeWeight> &dist_table,
+                    InternalRouteResult &min_route,
+                    std::vector<int> &min_loc_permutation)
+{
+}
+}
+}
+#endif // TRIP_BRUTE_FORCE_HPP

appveyor-build.bat

@@ -0,0 +1,120 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+SET PROJECT_DIR=%CD%
+ECHO PROJECT_DIR^: %PROJECT_DIR%
+
+ECHO activating VS command prompt ...
+SET PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH%
+CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
+
+ECHO platform^: %platform%
+:: HARDCODE "x64" as it is uppercase on AppVeyor and download from S3 is case sensitive
+SET DEPSPKG=osrm-deps-win-x64-14.0.7z
+
+:: local development
+ECHO LOCAL_DEV^: %LOCAL_DEV%
+IF NOT DEFINED LOCAL_DEV SET LOCAL_DEV=0
+IF DEFINED LOCAL_DEV IF %LOCAL_DEV% EQU 1 IF EXIST %DEPSPKG% ECHO skipping deps download && GOTO SKIPDL
+
+IF EXIST %DEPSPKG% DEL %DEPSPKG%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO downloading %DEPSPKG%
+powershell Invoke-WebRequest https://mapbox.s3.amazonaws.com/windows-builds/windows-build-deps/$env:DEPSPKG -OutFile $env:PROJECT_DIR\$env:DEPSPKG
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+:SKIPDL
+
+IF EXIST osrm-deps ECHO deleting osrm-deps... && RD /S /Q osrm-deps
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+IF EXIST build ECHO deletings build dir... && RD /S /Q build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+7z -y x %DEPSPKG% | %windir%\system32\FIND "ing archive"
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+MKDIR build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+cd build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET OSRMDEPSDIR=%PROJECT_DIR%\osrm-deps
+set PREFIX=%OSRMDEPSDIR%/libs
+set BOOST_ROOT=%OSRMDEPSDIR%/boost
+set TBB_INSTALL_DIR=%OSRMDEPSDIR%/tbb
+set TBB_ARCH_PLATFORM=intel64/vc14
+
+ECHO calling cmake ....
+cmake .. ^
+-G "Visual Studio 14 Win64" ^
+-DBOOST_ROOT=%BOOST_ROOT% ^
+-DBoost_ADDITIONAL_VERSIONS=1.58 ^
+-DBoost_USE_MULTITHREADED=ON ^
+-DBoost_USE_STATIC_LIBS=ON ^
+-DCMAKE_BUILD_TYPE=%CONFIGURATION% ^
+-DCMAKE_INSTALL_PREFIX=%PREFIX%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO building ...
+msbuild OSRM.sln ^
+/p:Configuration=%Configuration% ^
+/p:Platform=x64 ^
+/t:rebuild ^
+/p:BuildInParallel=true ^
+/m:%NUMBER_OF_PROCESSORS% ^
+/toolsversion:14.0 ^
+/p:PlatformToolset=v140 ^
+/clp:Verbosity=normal ^
+/nologo ^
+/flp1:logfile=build_errors.txt;errorsonly ^
+/flp2:logfile=build_warnings.txt;warningsonly
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+CD %PROJECT_DIR%\build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET PATH=%PROJECT_DIR%\osrm-deps\libs\bin;%PATH%
+
+ECHO running datastructure-tests.exe ...
+%Configuration%\datastructure-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+ECHO running algorithm-tests.exe ...
+%Configuration%\algorithm-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+IF NOT "%APPVEYOR_REPO_BRANCH%"=="develop" GOTO DONE
+ECHO ========= CREATING PACKAGES ==========
+
+CD %PROJECT_DIR%\build\%Configuration%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET P=%PROJECT_DIR%
+SET ZIP= %P%\osrm_%Configuration%.zip
+IF EXIST %ZIP% ECHO deleting %ZIP% && DEL /F /Q %ZIP%
+IF %ERRORLEVEL% NEQ 0 ECHO deleting %ZIP% FAILED && GOTO ERROR
+
+7z a %ZIP% *.lib *.exe *.pdb %P%/osrm-deps/libs/bin/*.dll -tzip -mx9 | %windir%\system32\FIND "ing archive"
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+CD ..\..\profiles
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO disk=c:\temp\stxxl,10000,wincall > .stxxl.txt
+7z a %ZIP% * -tzip -mx9 | %windir%\system32\FIND "ing archive"
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+GOTO DONE
+
+:ERROR
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ECHO ERRORLEVEL^: %ERRORLEVEL%
+SET EL=%ERRORLEVEL%
+
+:DONE
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+EXIT /b %EL%

appveyor.yml

@@ -1,60 +1,29 @@
 environment:
   matrix:
-  - configuration: Debug
   - configuration: Release
-
-# branches to build
-branches:
-  # whitelist
-  only:
-    - develop
+#  - configuration: Debug
 
 # scripts that are called at very beginning, before repo cloning
 init:
   - git config --global core.autocrlf input
 
+os: Visual Studio 2015
+
 # clone directory
 clone_folder: c:\projects\osrm
 
 platform: x64
 
-install:
-  # by default, all script lines are interpreted as batch
-  - nuget install protobuf
-  - cd c:\projects\osrm
-  - curl -O http://build.project-osrm.org/libs_osrm_%Configuration%.7z
-  - 7z x libs_osrm_%Configuration%.7z | find ":"
-
 build_script:
-  - cd c:/projects/osrm
-  - mkdir build
-  - cd build
-  - echo Running cmake...
-  - call "%VS120COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64
-  - SET PATH=C:\Program Files (x86)\MSBuild\12.0\bin\;%PATH%
-  - SET P=c:/projects/osrm
-  - set TBB_INSTALL_DIR=%P%/tbb
-  - set TBB_ARCH_PLATFORM=intel64/vc12
-  - cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_ADDITIONAL_VERSIONS=1.57 -DBoost_USE_STATIC_LIBS=ON -T CTP_Nov2013
-  - msbuild /clp:Verbosity=minimal /nologo OSRM.sln
-  - msbuild /clp:Verbosity=minimal /nologo tests.vcxproj
-  - cd %Configuration%
-  - if "%APPVEYOR_REPO_BRANCH%"=="develop" (7z a %P%/osrm_%Configuration%.zip *.exe *.pdb %P%/libs/bin/*.dll -tzip)
-  - cd ..\..\profiles
-  - echo disk=c:\temp\stxxl,10000,wincall > .stxxl.txt
-  - if "%APPVEYOR_REPO_BRANCH%"=="develop" (7z a %P%/osrm_%Configuration%.zip * -tzip)
-  - set PATH=%PATH%;c:/projects/osrm/libs/bin
-  - cd c:/projects/osrm/build/%Configuration%
-  - datastructure-tests.exe
-  - algorithm-tests.exe
+  - CALL appveyor-build.bat
 
 test: off
 
 artifacts:
-  - path: osrm_Debug.zip
-    name: osrm_Debug.zip
   - path: osrm_Release.zip
     name: osrm_Release.zip
+#  - path: osrm_Debug.zip
+#    name: osrm_Debug.zip
 
 deploy:
   provider: FTP

build-local.bat

@@ -0,0 +1,33 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+SET PLATFORM=x64
+SET CONFIGURATION=Release
+::SET LOCAL_DEV=1
+
+FOR /F "tokens=*" %%i in ('git rev-parse --abbrev-ref HEAD') do SET APPVEYOR_REPO_BRANCH=%%i
+ECHO APPVEYOR_REPO_BRANCH^: %APPVEYOR_REPO_BRANCH%
+
+SET PATH=C:\mb\windows-builds-64\tmp-bin\cmake-3.1.0-win32-x86\bin;%PATH%
+SET PATH=C:\Program Files\7-Zip;%PATH%
+
+powershell Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted -Force
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+CALL appveyor-build.bat
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+GOTO DONE
+
+
+:ERROR
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ECHO ERRORLEVEL^: %ERRORLEVEL%
+SET EL=%ERRORLEVEL%
+
+:DONE
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+EXIT /b %EL%

cmake/CPackDebianConfig.cmake

@@ -34,7 +34,7 @@ SET(CPACK_DEBIAN_PACKAGE_SECTION     "devel")
 SET(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Open Source Routing Machine (OSRM) is a high-performance routing engine.
   It combines sophisticated routing algorithms with the open and free data of the OpenStreetMap."
 )
-SET(CPACK_DEBIAN_PACKAGE_DEPENDS     "libc6-dev, libprotobuf-dev, libosmpbf-dev, libbz2-1.0, libstxxl1, libxml2, libzip2, liblua5.1-0, libtbb2, libboost-all-dev")
+SET(CPACK_DEBIAN_PACKAGE_DEPENDS     "libc6-dev, libbz2-1.0, libstxxl1, libxml2, libzip2, liblua5.1-0, libtbb2, libboost-all-dev")
 
 file(GLOB_RECURSE ProfileGlob ${CMAKE_SOURCE_DIR}/profiles/*)
 install(FILES ${ProfileGlob} DESTINATION "share/doc/${LOWER_PROJECT_NAME}/profiles")

cmake/FindOSMPBF.cmake

@@ -1,54 +0,0 @@
-# Locate OSMPBF library
-# This module defines
-#  OSMPBF_FOUND, if false, do not try to link to OSMPBF
-#  OSMPBF_LIBRARIES
-#  OSMPBF_INCLUDE_DIR, where to find OSMPBF.hpp
-#
-# Note that the expected include convention is
-#  #include <osmpbf/osmpbf.h>
-# and not
-#  #include <osmpbf.h>
-
-IF( NOT OSMPBF_FIND_QUIETLY )
-    MESSAGE(STATUS "Looking for OSMPBF...")
-ENDIF()
-
-FIND_PATH(OSMPBF_INCLUDE_DIR osmpbf.h
-  HINTS
-  $ENV{OSMPBF_DIR}
-  PATH_SUFFIXES OSMPBF include/osmpbf include
-  PATHS
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt/local # DarwinPorts
-  /opt
-)
-
-FIND_LIBRARY(OSMPBF_LIBRARY
-  NAMES osmpbf
-  HINTS
-  $ENV{OSMPBF_DIR}
-  PATH_SUFFIXES lib64 lib
-  PATHS
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt/local
-  /opt
-)
-
-INCLUDE(FindPackageHandleStandardArgs)
-# handle the QUIETLY and REQUIRED arguments and set OSMPBF_FOUND to TRUE if
-# all listed variables are TRUE
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(OSMPBF  DEFAULT_MSG  OSMPBF_LIBRARY OSMPBF_INCLUDE_DIR)
-
-IF( NOT OSMPBF_FIND_QUIETLY )
-    IF( OSMPBF_FOUND )
-        MESSAGE(STATUS "Found OSMPBF: ${OSMPBF_LIBRARY}" )
-    ENDIF()
-ENDIF()
-
-#MARK_AS_ADVANCED(OSMPBF_INCLUDE_DIR OSMPBF_LIBRARIES OSMPBF_LIBRARY OSMPBF_LIBRARY_DBG) 

cmake/FingerPrint-Config.cmake

@@ -1,10 +1,24 @@
 set(OLDFILE ${SOURCE_DIR}/util/fingerprint_impl.hpp)
-if (EXISTS ${OLDFILE})
-	file(REMOVE_RECURSE ${OLDFILE})
-endif()
+set(NEWFILE ${OLDFILE}.tmp)
+set(INFILE ${OLDFILE}.in)
 file(MD5 ${SOURCE_DIR}/prepare.cpp MD5PREPARE)
 file(MD5 ${SOURCE_DIR}/data_structures/static_rtree.hpp MD5RTREE)
 file(MD5 ${SOURCE_DIR}/util/graph_loader.hpp MD5GRAPH)
 file(MD5 ${SOURCE_DIR}/server/data_structures/internal_datafacade.hpp MD5OBJECTS)
 
-CONFIGURE_FILE(${SOURCE_DIR}/util/fingerprint_impl.hpp.in ${SOURCE_DIR}/util/fingerprint_impl.hpp)
+CONFIGURE_FILE(${INFILE} ${NEWFILE})
+
+file(MD5 ${NEWFILE} MD5NEW)
+
+if (EXISTS ${OLDFILE})
+    file(MD5 ${OLDFILE} MD5OLD)
+    if(NOT ${MD5NEW} STREQUAL ${MD5OLD})
+	    file(REMOVE_RECURSE ${OLDFILE})
+        file(RENAME ${NEWFILE} ${OLDFILE})
+    else()
+        file(REMOVE_RECURSE ${NEWFILE})
+        message(STATUS "Fingerprint unchanged, not regenerating")
+    endif()
+else()
+    file(RENAME ${NEWFILE} ${OLDFILE})
+endif()

contractor/contractor.hpp

@@ -171,7 +171,8 @@ class Contractor
             {
                 SimpleLogger().Write(logWARNING)
                     << "Edge weight large -> "
-                    << static_cast<unsigned int>(std::max(diter->weight, 1));
+                    << static_cast<unsigned int>(std::max(diter->weight, 1)) << " : "
+                    << static_cast<unsigned int>(diter->source) << " -> " << static_cast<unsigned int>(diter->target);
             }
 #endif
             edges.emplace_back(diter->source, diter->target,
@@ -186,6 +187,7 @@ class Contractor
         }
         // clear input vector
         input_edge_list.clear();
+        // FIXME not sure if we need this
         edges.shrink_to_fit();
 
         tbb::parallel_sort(edges.begin(), edges.end());
@@ -282,7 +284,7 @@ class Contractor
 
     ~Contractor() {}
 
-    void Run()
+    void Run( double core_factor = 1.0 )
     {
         // for the preperation we can use a big grain size, which is much faster (probably cache)
         constexpr size_t InitGrainSize = 100000;
@@ -304,12 +306,13 @@ class Contractor
         std::vector<RemainingNodeData> remaining_nodes(number_of_nodes);
         std::vector<float> node_priorities(number_of_nodes);
         std::vector<NodePriorityData> node_data(number_of_nodes);
+        is_core_node.resize(number_of_nodes, false);
 
         // initialize priorities in parallel
         tbb::parallel_for(tbb::blocked_range<int>(0, number_of_nodes, InitGrainSize),
                           [&remaining_nodes](const tbb::blocked_range<int> &range)
                           {
-                              for (int x = range.begin(); x != range.end(); ++x)
+                              for (int x = range.begin(), end = range.end(); x != end; ++x)
                               {
                                   remaining_nodes[x].id = x;
                               }
@@ -321,7 +324,7 @@ class Contractor
                               const tbb::blocked_range<int> &range)
                           {
                               ContractorThreadData *data = thread_data_list.getThreadData();
-                              for (int x = range.begin(); x != range.end(); ++x)
+                              for (int x = range.begin(), end = range.end(); x != end; ++x)
                               {
                                   node_priorities[x] =
                                       this->EvaluateNodePriority(data, &node_data[x], x);
@@ -331,9 +334,9 @@ class Contractor
                   << std::flush;
 
         bool flushed_contractor = false;
-        while (number_of_nodes > 2 && number_of_contracted_nodes < number_of_nodes)
+        while (number_of_nodes > 2 && number_of_contracted_nodes < static_cast<NodeID>(number_of_nodes * core_factor) )
         {
-            if (!flushed_contractor && (number_of_contracted_nodes > (number_of_nodes * 0.65)))
+            if (!flushed_contractor && (number_of_contracted_nodes > static_cast<NodeID>(number_of_nodes * 0.65 * core_factor)))
             {
                 DeallocatingVector<ContractorEdge> new_edge_set; // this one is not explicitely
                                                                  // cleared since it goes out of
@@ -347,7 +350,7 @@ class Contractor
                 std::vector<float> new_node_priority(remaining_nodes.size());
                 // this map gives the old IDs from the new ones, necessary to get a consistent graph
                 // at the end of contraction
-                orig_node_id_to_new_id_map.resize(remaining_nodes.size());
+                orig_node_id_from_new_node_id_map.resize(remaining_nodes.size());
                 // this map gives the new IDs from the old ones, necessary to remap targets from the
                 // remaining graph
                 std::vector<NodeID> new_node_id_from_orig_id_map(number_of_nodes, UINT_MAX);
@@ -357,7 +360,7 @@ class Contractor
                 for (const auto new_node_id : osrm::irange<std::size_t>(0, remaining_nodes.size()))
                 {
                     // create renumbering maps in both directions
-                    orig_node_id_to_new_id_map[new_node_id] = remaining_nodes[new_node_id].id;
+                    orig_node_id_from_new_node_id_map[new_node_id] = remaining_nodes[new_node_id].id;
                     new_node_id_from_orig_id_map[remaining_nodes[new_node_id].id] = new_node_id;
                     new_node_priority[new_node_id] =
                         node_priorities[remaining_nodes[new_node_id].id];
@@ -427,7 +430,7 @@ class Contractor
                               {
                                   ContractorThreadData *data = thread_data_list.getThreadData();
                                   // determine independent node set
-                                  for (int i = range.begin(); i != range.end(); ++i)
+                                  for (int i = range.begin(), end = range.end(); i != end; ++i)
                                   {
                                       const NodeID node = remaining_nodes[i].id;
                                       remaining_nodes[i].is_independent =
@@ -448,7 +451,7 @@ class Contractor
                 [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<int> &range)
                 {
                     ContractorThreadData *data = thread_data_list.getThreadData();
-                    for (int position = range.begin(); position != range.end(); ++position)
+                    for (int position = range.begin(), end = range.end(); position != end; ++position)
                     {
                         const NodeID x = remaining_nodes[position].id;
                         this->ContractNode<false>(data, x);
@@ -467,7 +470,7 @@ class Contractor
                 [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<int> &range)
                 {
                     ContractorThreadData *data = thread_data_list.getThreadData();
-                    for (int position = range.begin(); position != range.end(); ++position)
+                    for (int position = range.begin(), end = range.end(); position != end; ++position)
                     {
                         const NodeID x = remaining_nodes[position].id;
                         this->DeleteIncomingEdges(data, x);
@@ -505,7 +508,7 @@ class Contractor
                     const tbb::blocked_range<int> &range)
                 {
                     ContractorThreadData *data = thread_data_list.getThreadData();
-                    for (int position = range.begin(); position != range.end(); ++position)
+                    for (int position = range.begin(), end = range.end(); position != end; ++position)
                     {
                         NodeID x = remaining_nodes[position].id;
                         this->UpdateNodeNeighbours(node_priorities, node_data, data, x);
@@ -522,7 +525,7 @@ class Contractor
             //            unsigned quaddegree = 0;
             //
             //            for(unsigned i = 0; i < remaining_nodes.size(); ++i) {
-            //                unsigned degree = contractor_graph->EndEdges(remaining_nodes[i].first)
+            //                unsigned degree = contractor_graph->EndEdges(remaining_nodes[i].id)
             //                -
             //                contractor_graph->BeginEdges(remaining_nodes[i].first);
             //                if(degree > maxdegree)
@@ -544,9 +547,32 @@ class Contractor
             p.printStatus(number_of_contracted_nodes);
         }
 
+        if (remaining_nodes.size() > 2)
+        {
+            // TODO: for small cores a sorted array of core ids might also work good
+            for (const auto& node : remaining_nodes)
+            {
+                auto orig_id = orig_node_id_from_new_node_id_map[node.id];
+                is_core_node[orig_id] = true;
+            }
+        }
+        else
+        {
+            // in this case we don't need core markers since we fully contracted
+            // the graph
+            is_core_node.clear();
+        }
+
+        SimpleLogger().Write() << "[core] " << remaining_nodes.size() << " nodes " << contractor_graph->GetNumberOfEdges() << " edges." << std::endl;
+
         thread_data_list.data.clear();
     }
 
+    inline void GetCoreMarker(std::vector<bool> &out_is_core_node)
+    {
+        out_is_core_node.swap(is_core_node);
+    }
+
     template <class Edge> inline void GetEdges(DeallocatingVector<Edge> &edges)
     {
         Percent p(contractor_graph->GetNumberOfNodes());
@@ -562,10 +588,10 @@ class Contractor
                 {
                     const NodeID target = contractor_graph->GetTarget(edge);
                     const ContractorGraph::EdgeData &data = contractor_graph->GetEdgeData(edge);
-                    if (!orig_node_id_to_new_id_map.empty())
+                    if (!orig_node_id_from_new_node_id_map.empty())
                     {
-                        new_edge.source = orig_node_id_to_new_id_map[node];
-                        new_edge.target = orig_node_id_to_new_id_map[target];
+                        new_edge.source = orig_node_id_from_new_node_id_map[node];
+                        new_edge.target = orig_node_id_from_new_node_id_map[target];
                     }
                     else
                     {
@@ -576,9 +602,10 @@ class Contractor
                     BOOST_ASSERT_MSG(UINT_MAX != new_edge.target, "Target id invalid");
                     new_edge.data.distance = data.distance;
                     new_edge.data.shortcut = data.shortcut;
-                    if (!data.is_original_via_node_ID && !orig_node_id_to_new_id_map.empty())
+                    if (!data.is_original_via_node_ID && !orig_node_id_from_new_node_id_map.empty())
                     {
-                        new_edge.data.id = orig_node_id_to_new_id_map[data.id];
+                        // tranlate the _node id_ of the shortcutted node
+                        new_edge.data.id = orig_node_id_from_new_node_id_map[data.id];
                     }
                     else
                     {
@@ -593,10 +620,10 @@ class Contractor
             }
         }
         contractor_graph.reset();
-        orig_node_id_to_new_id_map.clear();
-        orig_node_id_to_new_id_map.shrink_to_fit();
+        orig_node_id_from_new_node_id_map.clear();
+        orig_node_id_from_new_node_id_map.shrink_to_fit();
 
-        BOOST_ASSERT(0 == orig_node_id_to_new_id_map.capacity());
+        BOOST_ASSERT(0 == orig_node_id_from_new_node_id_map.capacity());
 
         edges.append(external_edge_list.begin(), external_edge_list.end());
         external_edge_list.clear();
@@ -953,9 +980,9 @@ class Contractor
     }
 
     std::shared_ptr<ContractorGraph> contractor_graph;
-    std::vector<ContractorGraph::InputEdge> contracted_edge_list;
     stxxl::vector<QueryEdge> external_edge_list;
-    std::vector<NodeID> orig_node_id_to_new_id_map;
+    std::vector<NodeID> orig_node_id_from_new_node_id_map;
+    std::vector<bool> is_core_node;
     XORFastHash fast_hash;
 };
 

contractor/contractor_options.cpp

@@ -0,0 +1,140 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "contractor_options.hpp"
+
+#include "../util/git_sha.hpp"
+#include "../util/simple_logger.hpp"
+
+#include <boost/filesystem.hpp>
+#include <boost/program_options.hpp>
+
+#include <tbb/task_scheduler_init.h>
+
+return_code
+ContractorOptions::ParseArguments(int argc, char *argv[], ContractorConfig &contractor_config)
+{
+    // declare a group of options that will be allowed only on command line
+    boost::program_options::options_description generic_options("Options");
+    generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message")(
+        "config,c", boost::program_options::value<boost::filesystem::path>(&contractor_config.config_file_path)
+                        ->default_value("contractor.ini"),
+        "Path to a configuration file.");
+
+    // declare a group of options that will be allowed both on command line and in config file
+    boost::program_options::options_description config_options("Configuration");
+    config_options.add_options()(
+        "restrictions,r",
+        boost::program_options::value<boost::filesystem::path>(&contractor_config.restrictions_path),
+        "Restrictions file in .osrm.restrictions format")(
+        "profile,p", boost::program_options::value<boost::filesystem::path>(&contractor_config.profile_path)
+                         ->default_value("profile.lua"),
+        "Path to LUA routing profile")(
+        "threads,t", boost::program_options::value<unsigned int>(&contractor_config.requested_num_threads)
+                         ->default_value(tbb::task_scheduler_init::default_num_threads()),
+        "Number of threads to use")(
+		"core,k", boost::program_options::value<double>(&contractor_config.core_factor)
+						 ->default_value(1.0),"Percentage of the graph (in vertices) to contract [0.1]");
+
+
+
+    // hidden options, will be allowed both on command line and in config file, but will not be
+    // shown to the user
+    boost::program_options::options_description hidden_options("Hidden options");
+    hidden_options.add_options()(
+        "input,i", boost::program_options::value<boost::filesystem::path>(&contractor_config.osrm_input_path),
+        "Input file in .osm, .osm.bz2 or .osm.pbf format");
+
+    // positional option
+    boost::program_options::positional_options_description positional_options;
+    positional_options.add("input", 1);
+
+    // combine above options for parsing
+    boost::program_options::options_description cmdline_options;
+    cmdline_options.add(generic_options).add(config_options).add(hidden_options);
+
+    boost::program_options::options_description config_file_options;
+    config_file_options.add(config_options).add(hidden_options);
+
+    boost::program_options::options_description visible_options(
+        "Usage: " + boost::filesystem::basename(argv[0]) + " <input.osrm> [options]");
+    visible_options.add(generic_options).add(config_options);
+
+    // parse command line options
+    boost::program_options::variables_map option_variables;
+    boost::program_options::store(boost::program_options::command_line_parser(argc, argv)
+                                      .options(cmdline_options)
+                                      .positional(positional_options)
+                                      .run(),
+                                  option_variables);
+
+    const auto &temp_config_path = option_variables["config"].as<boost::filesystem::path>();
+    if (boost::filesystem::is_regular_file(temp_config_path))
+    {
+        boost::program_options::store(boost::program_options::parse_config_file<char>(
+                                          temp_config_path.string().c_str(), cmdline_options, true),
+                                      option_variables);
+    }
+
+    if (option_variables.count("version"))
+    {
+        SimpleLogger().Write() << g_GIT_DESCRIPTION;
+        return return_code::exit;
+    }
+
+    if (option_variables.count("help"))
+    {
+        SimpleLogger().Write() << "\n" << visible_options;
+        return return_code::exit;
+    }
+
+    boost::program_options::notify(option_variables);
+
+    if (!option_variables.count("restrictions"))
+    {
+        contractor_config.restrictions_path = contractor_config.osrm_input_path.string() + ".restrictions";
+    }
+
+    if (!option_variables.count("input"))
+    {
+        SimpleLogger().Write() << "\n" << visible_options;
+        return return_code::fail;
+    }
+
+    return return_code::ok;
+}
+
+void ContractorOptions::GenerateOutputFilesNames(ContractorConfig &contractor_config)
+{
+    contractor_config.node_output_path = contractor_config.osrm_input_path.string() + ".nodes";
+    contractor_config.core_output_path = contractor_config.osrm_input_path.string() + ".core";
+    contractor_config.edge_output_path = contractor_config.osrm_input_path.string() + ".edges";
+    contractor_config.geometry_output_path = contractor_config.osrm_input_path.string() + ".geometry";
+    contractor_config.graph_output_path = contractor_config.osrm_input_path.string() + ".hsgr";
+    contractor_config.rtree_nodes_output_path = contractor_config.osrm_input_path.string() + ".ramIndex";
+    contractor_config.rtree_leafs_output_path = contractor_config.osrm_input_path.string() + ".fileIndex";
+}

contractor/contractor_options.hpp

@@ -0,0 +1,75 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef CONTRACTOR_OPTIONS_HPP
+#define CONTRACTOR_OPTIONS_HPP
+
+#include <boost/filesystem/path.hpp>
+
+#include <string>
+
+enum class return_code : unsigned
+{
+    ok,
+    fail,
+    exit
+};
+
+struct ContractorConfig
+{
+    ContractorConfig() noexcept : requested_num_threads(0) {}
+
+    boost::filesystem::path config_file_path;
+    boost::filesystem::path osrm_input_path;
+    boost::filesystem::path restrictions_path;
+    boost::filesystem::path profile_path;
+
+    std::string node_output_path;
+    std::string core_output_path;
+    std::string edge_output_path;
+    std::string geometry_output_path;
+    std::string graph_output_path;
+    std::string rtree_nodes_output_path;
+    std::string rtree_leafs_output_path;
+
+    unsigned requested_num_threads;
+
+    //A percentage of vertices that will be contracted for the hierarchy.
+    //Offers a trade-off between preprocessing and query time.
+    //The remaining vertices form the core of the hierarchy 
+    //(e.g. 0.8 contracts 80 percent of the hierarchy, leaving a core of 20%)
+    double core_factor;
+};
+
+struct ContractorOptions
+{
+    static return_code ParseArguments(int argc, char *argv[], ContractorConfig &extractor_config);
+
+    static void GenerateOutputFilesNames(ContractorConfig &extractor_config);
+};
+
+#endif // EXTRACTOR_OPTIONS_HPP

contractor/edge_based_graph_factory.cpp

@@ -26,7 +26,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "edge_based_graph_factory.hpp"
-#include "../algorithms/tiny_components.hpp"
 #include "../data_structures/percent.hpp"
 #include "../util/compute_angle.hpp"
 #include "../util/integer_range.hpp"
@@ -41,20 +40,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <limits>
 
 EdgeBasedGraphFactory::EdgeBasedGraphFactory(
-    const std::shared_ptr<NodeBasedDynamicGraph> &node_based_graph,
-    std::unique_ptr<RestrictionMap> restriction_map,
-    std::vector<NodeID> &barrier_node_list,
-    std::vector<NodeID> &traffic_light_node_list,
-    std::vector<QueryNode> &node_info_list,
-    SpeedProfileProperties &speed_profile)
-    : speed_profile(speed_profile),
-      m_number_of_edge_based_nodes(std::numeric_limits<unsigned>::max()),
-      m_node_info_list(node_info_list), m_node_based_graph(node_based_graph),
-      m_restriction_map(std::move(restriction_map)), max_id(0), removed_node_count(0)
+    std::shared_ptr<NodeBasedDynamicGraph> node_based_graph,
+    const CompressedEdgeContainer &compressed_edge_container,
+    const std::unordered_set<NodeID> &barrier_nodes,
+    const std::unordered_set<NodeID> &traffic_lights,
+    std::shared_ptr<const RestrictionMap> restriction_map,
+    const std::vector<QueryNode> &node_info_list,
+    SpeedProfileProperties speed_profile)
+    : m_max_edge_id(0), m_node_info_list(node_info_list), m_node_based_graph(std::move(node_based_graph)),
+      m_restriction_map(std::move(restriction_map)), m_barrier_nodes(barrier_nodes),
+      m_traffic_lights(traffic_lights), m_compressed_edge_container(compressed_edge_container),
+      speed_profile(std::move(speed_profile))
 {
-    // insert into unordered sets for fast lookup
-    m_barrier_nodes.insert(barrier_node_list.begin(), barrier_node_list.end());
-    m_traffic_lights.insert(traffic_light_node_list.begin(), traffic_light_node_list.end());
 }
 
 void EdgeBasedGraphFactory::GetEdgeBasedEdges(DeallocatingVector<EdgeBasedEdge> &output_edge_list)
@@ -77,9 +74,13 @@ void EdgeBasedGraphFactory::GetEdgeBasedNodes(std::vector<EdgeBasedNode> &nodes)
     nodes.swap(m_edge_based_node_list);
 }
 
+unsigned EdgeBasedGraphFactory::GetHighestEdgeID()
+{
+    return m_max_edge_id;
+}
+
 void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,
-                                                const NodeID node_v,
-                                                const unsigned component_id)
+                                                const NodeID node_v)
 {
     // merge edges together into one EdgeBasedNode
     BOOST_ASSERT(node_u != SPECIAL_NODEID);
@@ -97,23 +98,21 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,
 
     const EdgeData &reverse_data = m_node_based_graph->GetEdgeData(edge_id_2);
 
-    if (forward_data.edgeBasedNodeID == SPECIAL_NODEID &&
-        reverse_data.edgeBasedNodeID == SPECIAL_NODEID)
+    if (forward_data.edge_id == SPECIAL_NODEID &&
+        reverse_data.edge_id == SPECIAL_NODEID)
     {
         return;
     }
 
-    BOOST_ASSERT(m_geometry_compressor.HasEntryForID(edge_id_1) ==
-                 m_geometry_compressor.HasEntryForID(edge_id_2));
-    if (m_geometry_compressor.HasEntryForID(edge_id_1))
+    BOOST_ASSERT(m_compressed_edge_container.HasEntryForID(edge_id_1) ==
+                 m_compressed_edge_container.HasEntryForID(edge_id_2));
+    if (m_compressed_edge_container.HasEntryForID(edge_id_1))
     {
-        BOOST_ASSERT(m_geometry_compressor.HasEntryForID(edge_id_2));
+        BOOST_ASSERT(m_compressed_edge_container.HasEntryForID(edge_id_2));
 
         // reconstruct geometry and put in each individual edge with its offset
-        const std::vector<GeometryCompressor::CompressedNode> &forward_geometry =
-            m_geometry_compressor.GetBucketReference(edge_id_1);
-        const std::vector<GeometryCompressor::CompressedNode> &reverse_geometry =
-            m_geometry_compressor.GetBucketReference(edge_id_2);
+        const auto& forward_geometry = m_compressed_edge_container.GetBucketReference(edge_id_1);
+        const auto& reverse_geometry = m_compressed_edge_container.GetBucketReference(edge_id_2);
         BOOST_ASSERT(forward_geometry.size() == reverse_geometry.size());
         BOOST_ASSERT(0 != forward_geometry.size());
         const unsigned geometry_size = static_cast<unsigned>(forward_geometry.size());
@@ -146,15 +145,6 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,
 
         NodeID current_edge_source_coordinate_id = node_u;
 
-        if (SPECIAL_NODEID != forward_data.edgeBasedNodeID)
-        {
-            max_id = std::max(forward_data.edgeBasedNodeID, max_id);
-        }
-        if (SPECIAL_NODEID != reverse_data.edgeBasedNodeID)
-        {
-            max_id = std::max(reverse_data.edgeBasedNodeID, max_id);
-        }
-
         // traverse arrays from start and end respectively
         for (const auto i : osrm::irange(0u, geometry_size))
         {
@@ -165,12 +155,12 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,
 
             // build edges
             m_edge_based_node_list.emplace_back(
-                forward_data.edgeBasedNodeID, reverse_data.edgeBasedNodeID,
+                forward_data.edge_id, reverse_data.edge_id,
                 current_edge_source_coordinate_id, current_edge_target_coordinate_id,
-                forward_data.nameID, forward_geometry[i].second,
+                forward_data.name_id, forward_geometry[i].second,
                 reverse_geometry[geometry_size - 1 - i].second, forward_dist_prefix_sum[i],
-                reverse_dist_prefix_sum[i], m_geometry_compressor.GetPositionForID(edge_id_1),
-                component_id, i, forward_data.travel_mode, reverse_data.travel_mode);
+                reverse_dist_prefix_sum[i], m_compressed_edge_container.GetPositionForID(edge_id_1),
+                INVALID_COMPONENTID, i, forward_data.travel_mode, reverse_data.travel_mode);
             current_edge_source_coordinate_id = current_edge_target_coordinate_id;
 
             BOOST_ASSERT(m_edge_based_node_list.back().IsCompressed());
@@ -187,32 +177,33 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,
     }
     else
     {
-        BOOST_ASSERT(!m_geometry_compressor.HasEntryForID(edge_id_2));
+        BOOST_ASSERT(!m_compressed_edge_container.HasEntryForID(edge_id_2));
 
-        if (forward_data.edgeBasedNodeID != SPECIAL_NODEID)
+        if (forward_data.edge_id != SPECIAL_NODEID)
         {
-            BOOST_ASSERT(forward_data.forward);
+            BOOST_ASSERT(!forward_data.reversed);
         }
-        if (reverse_data.edgeBasedNodeID != SPECIAL_NODEID)
+        else
         {
-            BOOST_ASSERT(reverse_data.forward);
-        }
-        if (forward_data.edgeBasedNodeID == SPECIAL_NODEID)
-        {
-            BOOST_ASSERT(!forward_data.forward);
-        }
-        if (reverse_data.edgeBasedNodeID == SPECIAL_NODEID)
-        {
-            BOOST_ASSERT(!reverse_data.forward);
+            BOOST_ASSERT(forward_data.reversed);
         }
 
-        BOOST_ASSERT(forward_data.edgeBasedNodeID != SPECIAL_NODEID ||
-                     reverse_data.edgeBasedNodeID != SPECIAL_NODEID);
+        if (reverse_data.edge_id != SPECIAL_NODEID)
+        {
+            BOOST_ASSERT(!reverse_data.reversed);
+        }
+        else
+        {
+            BOOST_ASSERT(reverse_data.reversed);
+        }
+
+        BOOST_ASSERT(forward_data.edge_id != SPECIAL_NODEID ||
+                     reverse_data.edge_id != SPECIAL_NODEID);
 
         m_edge_based_node_list.emplace_back(
-            forward_data.edgeBasedNodeID, reverse_data.edgeBasedNodeID, node_u, node_v,
-            forward_data.nameID, forward_data.distance, reverse_data.distance, 0, 0, SPECIAL_EDGEID,
-            component_id, 0, forward_data.travel_mode, reverse_data.travel_mode);
+            forward_data.edge_id, reverse_data.edge_id, node_u, node_v,
+            forward_data.name_id, forward_data.distance, reverse_data.distance, 0, 0, SPECIAL_EDGEID,
+            INVALID_COMPONENTID, 0, forward_data.travel_mode, reverse_data.travel_mode);
         BOOST_ASSERT(!m_edge_based_node_list.back().IsCompressed());
     }
 }
@@ -230,16 +221,10 @@ void EdgeBasedGraphFactory::FlushVectorToStream(
 }
 
 void EdgeBasedGraphFactory::Run(const std::string &original_edge_data_filename,
-                                const std::string &geometry_filename,
                                 lua_State *lua_state)
 {
-
-    TIMER_START(geometry);
-    CompressGeometry();
-    TIMER_STOP(geometry);
-
     TIMER_START(renumber);
-    RenumberEdges();
+    m_max_edge_id = RenumberEdges() - 1;
     TIMER_STOP(renumber);
 
     TIMER_START(generate_nodes);
@@ -250,207 +235,46 @@ void EdgeBasedGraphFactory::Run(const std::string &original_edge_data_filename,
     GenerateEdgeExpandedEdges(original_edge_data_filename, lua_state);
     TIMER_STOP(generate_edges);
 
-    m_geometry_compressor.SerializeInternalVector(geometry_filename);
-
     SimpleLogger().Write() << "Timing statistics for edge-expanded graph:";
-    SimpleLogger().Write() << "Geometry compression: " << TIMER_SEC(geometry) << "s";
     SimpleLogger().Write() << "Renumbering edges: " << TIMER_SEC(renumber) << "s";
     SimpleLogger().Write() << "Generating nodes: " << TIMER_SEC(generate_nodes) << "s";
     SimpleLogger().Write() << "Generating edges: " << TIMER_SEC(generate_edges) << "s";
 }
 
-void EdgeBasedGraphFactory::CompressGeometry()
+
+/// Renumbers all _forward_ edges and sets the edge_id.
+/// A specific numbering is not important. Any unique ID will do.
+/// Returns the number of edge based nodes.
+unsigned EdgeBasedGraphFactory::RenumberEdges()
 {
-    SimpleLogger().Write() << "Removing graph geometry while preserving topology";
-
-    const unsigned original_number_of_nodes = m_node_based_graph->GetNumberOfNodes();
-    const unsigned original_number_of_edges = m_node_based_graph->GetNumberOfEdges();
-
-    Percent progress(original_number_of_nodes);
-
-    for (const NodeID node_v : osrm::irange(0u, original_number_of_nodes))
-    {
-        progress.printStatus(node_v);
-
-        // only contract degree 2 vertices
-        if (2 != m_node_based_graph->GetOutDegree(node_v))
-        {
-            continue;
-        }
-
-        // don't contract barrier node
-        if (m_barrier_nodes.end() != m_barrier_nodes.find(node_v))
-        {
-            continue;
-        }
-
-        // check if v is a via node for a turn restriction, i.e. a 'directed' barrier node
-        if (m_restriction_map->IsViaNode(node_v))
-        {
-            continue;
-        }
-
-        const bool reverse_edge_order =
-            !(m_node_based_graph->GetEdgeData(m_node_based_graph->BeginEdges(node_v)).forward);
-        const EdgeID forward_e2 = m_node_based_graph->BeginEdges(node_v) + reverse_edge_order;
-        BOOST_ASSERT(SPECIAL_EDGEID != forward_e2);
-        const EdgeID reverse_e2 = m_node_based_graph->BeginEdges(node_v) + 1 - reverse_edge_order;
-        BOOST_ASSERT(SPECIAL_EDGEID != reverse_e2);
-
-        const EdgeData &fwd_edge_data2 = m_node_based_graph->GetEdgeData(forward_e2);
-        const EdgeData &rev_edge_data2 = m_node_based_graph->GetEdgeData(reverse_e2);
-
-        const NodeID node_w = m_node_based_graph->GetTarget(forward_e2);
-        BOOST_ASSERT(SPECIAL_NODEID != node_w);
-        BOOST_ASSERT(node_v != node_w);
-        const NodeID node_u = m_node_based_graph->GetTarget(reverse_e2);
-        BOOST_ASSERT(SPECIAL_NODEID != node_u);
-        BOOST_ASSERT(node_u != node_v);
-
-        const EdgeID forward_e1 = m_node_based_graph->FindEdge(node_u, node_v);
-        BOOST_ASSERT(SPECIAL_EDGEID != forward_e1);
-        BOOST_ASSERT(node_v == m_node_based_graph->GetTarget(forward_e1));
-        const EdgeID reverse_e1 = m_node_based_graph->FindEdge(node_w, node_v);
-        BOOST_ASSERT(SPECIAL_EDGEID != reverse_e1);
-        BOOST_ASSERT(node_v == m_node_based_graph->GetTarget(reverse_e1));
-
-        const EdgeData &fwd_edge_data1 = m_node_based_graph->GetEdgeData(forward_e1);
-        const EdgeData &rev_edge_data1 = m_node_based_graph->GetEdgeData(reverse_e1);
-
-        if (m_node_based_graph->FindEdgeInEitherDirection(node_u, node_w) != SPECIAL_EDGEID)
-        {
-            continue;
-        }
-
-        if ( // TODO: rename to IsCompatibleTo
-            fwd_edge_data1.IsEqualTo(fwd_edge_data2) && rev_edge_data1.IsEqualTo(rev_edge_data2))
-        {
-            // Get distances before graph is modified
-            const int forward_weight1 = m_node_based_graph->GetEdgeData(forward_e1).distance;
-            const int forward_weight2 = m_node_based_graph->GetEdgeData(forward_e2).distance;
-
-            BOOST_ASSERT(0 != forward_weight1);
-            BOOST_ASSERT(0 != forward_weight2);
-
-            const int reverse_weight1 = m_node_based_graph->GetEdgeData(reverse_e1).distance;
-            const int reverse_weight2 = m_node_based_graph->GetEdgeData(reverse_e2).distance;
-
-            BOOST_ASSERT(0 != reverse_weight1);
-            BOOST_ASSERT(0 != forward_weight2);
-
-            const bool has_node_penalty = m_traffic_lights.find(node_v) != m_traffic_lights.end();
-
-            // add weight of e2's to e1
-            m_node_based_graph->GetEdgeData(forward_e1).distance += fwd_edge_data2.distance;
-            m_node_based_graph->GetEdgeData(reverse_e1).distance += rev_edge_data2.distance;
-            if (has_node_penalty)
-            {
-                m_node_based_graph->GetEdgeData(forward_e1).distance +=
-                    speed_profile.traffic_signal_penalty;
-                m_node_based_graph->GetEdgeData(reverse_e1).distance +=
-                    speed_profile.traffic_signal_penalty;
-            }
-
-            // extend e1's to targets of e2's
-            m_node_based_graph->SetTarget(forward_e1, node_w);
-            m_node_based_graph->SetTarget(reverse_e1, node_u);
-
-            // remove e2's (if bidir, otherwise only one)
-            m_node_based_graph->DeleteEdge(node_v, forward_e2);
-            m_node_based_graph->DeleteEdge(node_v, reverse_e2);
-
-            // update any involved turn restrictions
-            m_restriction_map->FixupStartingTurnRestriction(node_u, node_v, node_w);
-            m_restriction_map->FixupArrivingTurnRestriction(node_u, node_v, node_w,
-                                                            m_node_based_graph);
-
-            m_restriction_map->FixupStartingTurnRestriction(node_w, node_v, node_u);
-            m_restriction_map->FixupArrivingTurnRestriction(node_w, node_v, node_u,
-                                                            m_node_based_graph);
-
-            // store compressed geometry in container
-            m_geometry_compressor.CompressEdge(
-                forward_e1, forward_e2, node_v, node_w,
-                forward_weight1 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0),
-                forward_weight2);
-            m_geometry_compressor.CompressEdge(
-                reverse_e1, reverse_e2, node_v, node_u, reverse_weight1,
-                reverse_weight2 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0));
-            ++removed_node_count;
-
-            BOOST_ASSERT(m_node_based_graph->GetEdgeData(forward_e1).nameID ==
-                         m_node_based_graph->GetEdgeData(reverse_e1).nameID);
-        }
-    }
-    SimpleLogger().Write() << "removed " << removed_node_count << " nodes";
-    m_geometry_compressor.PrintStatistics();
-
-    unsigned new_node_count = 0;
-    unsigned new_edge_count = 0;
-
-    for (const auto i : osrm::irange(0u, m_node_based_graph->GetNumberOfNodes()))
-    {
-        if (m_node_based_graph->GetOutDegree(i) > 0)
-        {
-            ++new_node_count;
-            new_edge_count += (m_node_based_graph->EndEdges(i) - m_node_based_graph->BeginEdges(i));
-        }
-    }
-    SimpleLogger().Write() << "new nodes: " << new_node_count << ", edges " << new_edge_count;
-    SimpleLogger().Write() << "Node compression ratio: "
-                           << new_node_count / (double)original_number_of_nodes;
-    SimpleLogger().Write() << "Edge compression ratio: "
-                           << new_edge_count / (double)original_number_of_edges;
-}
-
-/**
- * Writes the id of the edge in the edge expanded graph (into the edge in the node based graph)
- */
-void EdgeBasedGraphFactory::RenumberEdges()
-{
-    // renumber edge based node IDs
+    // renumber edge based node of outgoing edges
     unsigned numbered_edges_count = 0;
     for (const auto current_node : osrm::irange(0u, m_node_based_graph->GetNumberOfNodes()))
     {
         for (const auto current_edge : m_node_based_graph->GetAdjacentEdgeRange(current_node))
         {
             EdgeData &edge_data = m_node_based_graph->GetEdgeData(current_edge);
-            if (!edge_data.forward)
+
+            // only number incoming edges
+            if (edge_data.reversed)
             {
                 continue;
             }
 
             BOOST_ASSERT(numbered_edges_count < m_node_based_graph->GetNumberOfEdges());
-            edge_data.edgeBasedNodeID = numbered_edges_count;
+            edge_data.edge_id = numbered_edges_count;
             ++numbered_edges_count;
 
-            BOOST_ASSERT(SPECIAL_NODEID != edge_data.edgeBasedNodeID);
+            BOOST_ASSERT(SPECIAL_NODEID != edge_data.edge_id);
         }
     }
-    m_number_of_edge_based_nodes = numbered_edges_count;
+
+    return numbered_edges_count;
 }
 
-/**
- * Creates the nodes in the edge expanded graph from edges in the node-based graph.
- */
+/// Creates the nodes in the edge expanded graph from edges in the node-based graph.
 void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
 {
-    SimpleLogger().Write() << "Identifying components of the (compressed) road network";
-
-    // Run a BFS on the undirected graph and identify small components
-    TarjanSCC<NodeBasedDynamicGraph> component_explorer(m_node_based_graph, *m_restriction_map,
-                                                        m_barrier_nodes);
-
-    component_explorer.run();
-
-    SimpleLogger().Write() << "identified: "
-                           << component_explorer.get_number_of_components() - removed_node_count
-                           << " (compressed) components";
-    SimpleLogger().Write() << "identified "
-                           << component_explorer.get_size_one_count() - removed_node_count
-                           << " (compressed) SCCs of size 1";
-    SimpleLogger().Write() << "generating edge-expanded nodes";
-
     Percent progress(m_node_based_graph->GetNumberOfNodes());
 
     // loop over all edges and generate new set of nodes
@@ -466,7 +290,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
             const NodeID node_v = m_node_based_graph->GetTarget(e1);
 
             BOOST_ASSERT(SPECIAL_NODEID != node_v);
-            // pick only every other edge
+            // pick only every other edge, since we have every edge as an outgoing
+            // and incoming egde
             if (node_u > node_v)
             {
                 continue;
@@ -474,33 +299,14 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
 
             BOOST_ASSERT(node_u < node_v);
 
-            // Note: edges that end on barrier nodes or on a turn restriction
-            // may actually be in two distinct components. We choose the smallest
-            const unsigned size_of_component =
-                std::min(component_explorer.get_component_size(node_u),
-                         component_explorer.get_component_size(node_v));
-
-            const unsigned id_of_smaller_component = [node_u, node_v, &component_explorer]
+            // if we found a non-forward edge reverse and try again
+            if (edge_data.edge_id == SPECIAL_NODEID)
             {
-                if (component_explorer.get_component_size(node_u) <
-                    component_explorer.get_component_size(node_v))
-                {
-                    return component_explorer.get_component_id(node_u);
-                }
-                return component_explorer.get_component_id(node_v);
-            }();
-
-            const bool component_is_tiny = size_of_component < 1000;
-
-            if (edge_data.edgeBasedNodeID == SPECIAL_NODEID)
-            {
-                InsertEdgeBasedNode(node_v, node_u,
-                                    (component_is_tiny ? id_of_smaller_component + 1 : 0));
+                InsertEdgeBasedNode(node_v, node_u);
             }
             else
             {
-                InsertEdgeBasedNode(node_u, node_v,
-                                    (component_is_tiny ? id_of_smaller_component + 1 : 0));
+                InsertEdgeBasedNode(node_u, node_v);
             }
         }
     }
@@ -509,9 +315,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
                            << " nodes in edge-expanded graph";
 }
 
-/**
- * Actually it also generates OriginalEdgeData and serializes them...
- */
+/// Actually it also generates OriginalEdgeData and serializes them...
 void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
     const std::string &original_edge_data_filename, lua_State *lua_state)
 {
@@ -543,7 +347,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         progress.printStatus(node_u);
         for (const EdgeID e1 : m_node_based_graph->GetAdjacentEdgeRange(node_u))
         {
-            if (!m_node_based_graph->GetEdgeData(e1).forward)
+            if (m_node_based_graph->GetEdgeData(e1).reversed)
             {
                 continue;
             }
@@ -556,7 +360,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
 
             for (const EdgeID e2 : m_node_based_graph->GetAdjacentEdgeRange(node_v))
             {
-                if (!m_node_based_graph->GetEdgeData(e2).forward)
+                if (m_node_based_graph->GetEdgeData(e2).reversed)
                 {
                     continue;
                 }
@@ -602,9 +406,9 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                 const EdgeData &edge_data1 = m_node_based_graph->GetEdgeData(e1);
                 const EdgeData &edge_data2 = m_node_based_graph->GetEdgeData(e2);
 
-                BOOST_ASSERT(edge_data1.edgeBasedNodeID != edge_data2.edgeBasedNodeID);
-                BOOST_ASSERT(edge_data1.forward);
-                BOOST_ASSERT(edge_data2.forward);
+                BOOST_ASSERT(edge_data1.edge_id != edge_data2.edge_id);
+                BOOST_ASSERT(!edge_data1.reversed);
+                BOOST_ASSERT(!edge_data2.reversed);
 
                 // the following is the core of the loop.
                 unsigned distance = edge_data1.distance;
@@ -615,14 +419,14 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
 
                 // unpack last node of first segment if packed
                 const auto first_coordinate =
-                    m_node_info_list[(m_geometry_compressor.HasEntryForID(e1)
-                                          ? m_geometry_compressor.GetLastNodeIDOfBucket(e1)
+                    m_node_info_list[(m_compressed_edge_container.HasEntryForID(e1)
+                                          ? m_compressed_edge_container.GetLastEdgeSourceID(e1)
                                           : node_u)];
 
                 // unpack first node of second segment if packed
                 const auto third_coordinate =
-                    m_node_info_list[(m_geometry_compressor.HasEntryForID(e2)
-                                          ? m_geometry_compressor.GetFirstNodeIDOfBucket(e2)
+                    m_node_info_list[(m_compressed_edge_container.HasEntryForID(e2)
+                                          ? m_compressed_edge_container.GetFirstEdgeTargetID(e2)
                                           : node_w)];
 
                 const double turn_angle = ComputeAngle::OfThreeFixedPointCoordinates(
@@ -636,7 +440,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                 }
                 distance += turn_penalty;
 
-                const bool edge_is_compressed = m_geometry_compressor.HasEntryForID(e1);
+                const bool edge_is_compressed = m_compressed_edge_container.HasEntryForID(e1);
 
                 if (edge_is_compressed)
                 {
@@ -644,8 +448,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                 }
 
                 original_edge_data_vector.emplace_back(
-                    (edge_is_compressed ? m_geometry_compressor.GetPositionForID(e1) : node_v),
-                    edge_data1.nameID, turn_instruction, edge_is_compressed,
+                    (edge_is_compressed ? m_compressed_edge_container.GetPositionForID(e1) : node_v),
+                    edge_data1.name_id, turn_instruction, edge_is_compressed,
                     edge_data2.travel_mode);
 
                 ++original_edges_counter;
@@ -655,12 +459,11 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                     FlushVectorToStream(edge_data_file, original_edge_data_vector);
                 }
 
-                BOOST_ASSERT(SPECIAL_NODEID != edge_data1.edgeBasedNodeID);
-                BOOST_ASSERT(SPECIAL_NODEID != edge_data2.edgeBasedNodeID);
+                BOOST_ASSERT(SPECIAL_NODEID != edge_data1.edge_id);
+                BOOST_ASSERT(SPECIAL_NODEID != edge_data2.edge_id);
 
-                m_edge_based_edge_list.emplace_back(
-                    EdgeBasedEdge(edge_data1.edgeBasedNodeID, edge_data2.edgeBasedNodeID,
-                                  m_edge_based_edge_list.size(), distance, true, false));
+                m_edge_based_edge_list.emplace_back(edge_data1.edge_id, edge_data2.edge_id,
+                                  m_edge_based_edge_list.size(), distance, true, false);
             }
         }
     }
@@ -689,7 +492,8 @@ int EdgeBasedGraphFactory::GetTurnPenalty(double angle, lua_State *lua_state) co
         try
         {
             // call lua profile to compute turn penalty
-            return luabind::call_function<int>(lua_state, "turn_function", 180. - angle);
+            double penalty = luabind::call_function<double>(lua_state, "turn_function", 180. - angle);
+            return static_cast<int>(penalty);
         }
         catch (const luabind::error &er)
         {
@@ -743,11 +547,11 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID node_u,
 
     // If street names stay the same and if we are certain that it is not a
     // a segment of a roundabout, we skip it.
-    if (data1.nameID == data2.nameID)
+    if (data1.name_id == data2.name_id && data1.travel_mode == data2.travel_mode)
     {
         // TODO: Here we should also do a small graph exploration to check for
         //      more complex situations
-        if (0 != data1.nameID || m_node_based_graph->GetOutDegree(node_v) <= 2)
+        if (0 != data1.name_id || m_node_based_graph->GetOutDegree(node_v) <= 2)
         {
             return TurnInstruction::NoTurn;
         }
@@ -756,7 +560,3 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID node_u,
     return TurnInstructionsClass::GetTurnDirectionOfInstruction(angle);
 }
 
-unsigned EdgeBasedGraphFactory::GetNumberOfEdgeBasedNodes() const
-{
-    return m_number_of_edge_based_nodes;
-}

contractor/edge_based_graph_factory.hpp

@@ -30,8 +30,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EDGE_BASED_GRAPH_FACTORY_HPP_
 #define EDGE_BASED_GRAPH_FACTORY_HPP_
 
-#include "geometry_compressor.hpp"
+#include "speed_profile.hpp"
 #include "../typedefs.h"
+#include "../data_structures/compressed_edge_container.hpp"
 #include "../data_structures/deallocating_vector.hpp"
 #include "../data_structures/edge_based_node.hpp"
 #include "../data_structures/original_edge_data.hpp"
@@ -57,72 +58,55 @@ class EdgeBasedGraphFactory
     EdgeBasedGraphFactory() = delete;
     EdgeBasedGraphFactory(const EdgeBasedGraphFactory &) = delete;
 
-    struct SpeedProfileProperties;
-
-    explicit EdgeBasedGraphFactory(const std::shared_ptr<NodeBasedDynamicGraph> &node_based_graph,
-                                   std::unique_ptr<RestrictionMap> restricion_map,
-                                   std::vector<NodeID> &barrier_node_list,
-                                   std::vector<NodeID> &traffic_light_node_list,
-                                   std::vector<QueryNode> &node_info_list,
-                                   SpeedProfileProperties &speed_profile);
+    explicit EdgeBasedGraphFactory(std::shared_ptr<NodeBasedDynamicGraph> node_based_graph,
+                                   const CompressedEdgeContainer &compressed_edge_container,
+                                   const std::unordered_set<NodeID> &barrier_nodes,
+                                   const std::unordered_set<NodeID> &traffic_lights,
+                                   std::shared_ptr<const RestrictionMap> restriction_map,
+                                   const std::vector<QueryNode> &node_info_list,
+                                   SpeedProfileProperties speed_profile);
 
     void Run(const std::string &original_edge_data_filename,
-             const std::string &geometry_filename,
              lua_State *lua_state);
 
     void GetEdgeBasedEdges(DeallocatingVector<EdgeBasedEdge> &edges);
 
     void GetEdgeBasedNodes(std::vector<EdgeBasedNode> &nodes);
 
+    unsigned GetHighestEdgeID();
+
     TurnInstruction AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w, const double angle) const;
 
     int GetTurnPenalty(double angle, lua_State *lua_state) const;
 
-    unsigned GetNumberOfEdgeBasedNodes() const;
-
-    struct SpeedProfileProperties
-    {
-        SpeedProfileProperties()
-            : traffic_signal_penalty(0), u_turn_penalty(0), has_turn_penalty_function(false)
-        {
-        }
-
-        int traffic_signal_penalty;
-        int u_turn_penalty;
-        bool has_turn_penalty_function;
-    } speed_profile;
-
   private:
     using EdgeData = NodeBasedDynamicGraph::EdgeData;
 
-    unsigned m_number_of_edge_based_nodes;
-
-    std::vector<QueryNode> m_node_info_list;
     std::vector<EdgeBasedNode> m_edge_based_node_list;
     DeallocatingVector<EdgeBasedEdge> m_edge_based_edge_list;
+    unsigned m_max_edge_id;
 
+    const std::vector<QueryNode>& m_node_info_list;
     std::shared_ptr<NodeBasedDynamicGraph> m_node_based_graph;
-    std::unordered_set<NodeID> m_barrier_nodes;
-    std::unordered_set<NodeID> m_traffic_lights;
+    std::shared_ptr<RestrictionMap const> m_restriction_map;
 
-    std::unique_ptr<RestrictionMap> m_restriction_map;
+    const std::unordered_set<NodeID>& m_barrier_nodes;
+    const std::unordered_set<NodeID>& m_traffic_lights;
+    const CompressedEdgeContainer& m_compressed_edge_container;
 
-    GeometryCompressor m_geometry_compressor;
+    SpeedProfileProperties speed_profile;
 
     void CompressGeometry();
-    void RenumberEdges();
+    unsigned RenumberEdges();
     void GenerateEdgeExpandedNodes();
     void GenerateEdgeExpandedEdges(const std::string &original_edge_data_filename,
                                    lua_State *lua_state);
 
-    void InsertEdgeBasedNode(const NodeID u, const NodeID v, const unsigned component_id);
+    void InsertEdgeBasedNode(const NodeID u, const NodeID v);
 
     void FlushVectorToStream(std::ofstream &edge_data_file,
                              std::vector<OriginalEdgeData> &original_edge_data_vector) const;
 
-    NodeID max_id;
-    std::size_t removed_node_count;
-
 };
 
 #endif /* EDGE_BASED_GRAPH_FACTORY_HPP_ */

contractor/processing_chain.cpp

@@ -28,8 +28,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "processing_chain.hpp"
 
 #include "contractor.hpp"
-
+#include "../algorithms/graph_compressor.hpp"
+#include "../algorithms/tarjan_scc.hpp"
 #include "../algorithms/crc32_processor.hpp"
+#include "../data_structures/compressed_edge_container.hpp"
 #include "../data_structures/deallocating_vector.hpp"
 #include "../data_structures/static_rtree.hpp"
 #include "../data_structures/restriction_map.hpp"
@@ -38,7 +40,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../util/graph_loader.hpp"
 #include "../util/integer_range.hpp"
 #include "../util/lua_util.hpp"
-#include "../util/make_unique.hpp"
 #include "../util/osrm_exception.hpp"
 #include "../util/simple_logger.hpp"
 #include "../util/string_util.hpp"
@@ -48,7 +49,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <boost/filesystem/fstream.hpp>
 #include <boost/program_options.hpp>
 
-#include <tbb/task_scheduler_init.h>
 #include <tbb/parallel_sort.h>
 
 #include <chrono>
@@ -57,163 +57,188 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <thread>
 #include <vector>
 
-Prepare::Prepare() : requested_num_threads(1) {}
-
 Prepare::~Prepare() {}
 
-int Prepare::Process(int argc, char *argv[])
+int Prepare::Run()
 {
-    LogPolicy::GetInstance().Unmute();
-    TIMER_START(preparing);
-    TIMER_START(expansion);
-
-    if (!ParseArguments(argc, argv))
-    {
-        return 0;
-    }
-    if (!boost::filesystem::is_regular_file(input_path))
-    {
-        SimpleLogger().Write(logWARNING) << "Input file " << input_path.string() << " not found!";
-        return 1;
-    }
-
-    if (!boost::filesystem::is_regular_file(profile_path))
-    {
-        SimpleLogger().Write(logWARNING) << "Profile " << profile_path.string() << " not found!";
-        return 1;
-    }
-
-    if (1 > requested_num_threads)
-    {
-        SimpleLogger().Write(logWARNING) << "Number of threads must be 1 or larger";
-        return 1;
-    }
-
-    const unsigned recommended_num_threads = tbb::task_scheduler_init::default_num_threads();
-
-    SimpleLogger().Write() << "Input file: " << input_path.filename().string();
-    SimpleLogger().Write() << "Restrictions file: " << restrictions_path.filename().string();
-    SimpleLogger().Write() << "Profile: " << profile_path.filename().string();
-    SimpleLogger().Write() << "Threads: " << requested_num_threads;
-    if (recommended_num_threads != requested_num_threads)
-    {
-        SimpleLogger().Write(logWARNING) << "The recommended number of threads is "
-                                         << recommended_num_threads
-                                         << "! This setting may have performance side-effects.";
-    }
-
-    tbb::task_scheduler_init init(requested_num_threads);
-
-    LogPolicy::GetInstance().Unmute();
-
-    FingerPrint fingerprint_orig;
-    CheckRestrictionsFile(fingerprint_orig);
-
-    boost::filesystem::ifstream input_stream(input_path, std::ios::in | std::ios::binary);
-
-    node_filename = input_path.string() + ".nodes";
-    edge_out = input_path.string() + ".edges";
-    geometry_filename = input_path.string() + ".geometry";
-    graph_out = input_path.string() + ".hsgr";
-    rtree_nodes_path = input_path.string() + ".ramIndex";
-    rtree_leafs_path = input_path.string() + ".fileIndex";
-
-    /*** Setup Scripting Environment ***/
-    // Create a new lua state
-    lua_State *lua_state = luaL_newstate();
-
-    // Connect LuaBind to this lua state
-    luabind::open(lua_state);
-
-    EdgeBasedGraphFactory::SpeedProfileProperties speed_profile;
-
-    if (!SetupScriptingEnvironment(lua_state, speed_profile))
-    {
-        return 1;
-    }
-
 #ifdef WIN32
 #pragma message("Memory consumption on Windows can be higher due to different bit packing")
 #else
-    static_assert(sizeof(ImportEdge) == 20,
-                  "changing ImportEdge type has influence on memory consumption!");
+    static_assert(sizeof(NodeBasedEdge) == 20,
+                  "changing NodeBasedEdge type has influence on memory consumption!");
+    static_assert(sizeof(EdgeBasedEdge) == 16,
+                  "changing EdgeBasedEdge type has influence on memory consumption!");
 #endif
-    NodeID number_of_node_based_nodes = readBinaryOSRMGraphFromStream(
-        input_stream, edge_list, barrier_node_list, traffic_light_list,
-        &internal_to_external_node_map, restriction_list);
-    input_stream.close();
 
-    if (edge_list.empty())
-    {
-        SimpleLogger().Write(logWARNING) << "The input data is empty, exiting.";
-        return 1;
-    }
+    TIMER_START(preparing);
 
-    SimpleLogger().Write() << restriction_list.size() << " restrictions, "
-                           << barrier_node_list.size() << " bollard nodes, "
-                           << traffic_light_list.size() << " traffic lights";
+    // Create a new lua state
+
+    SimpleLogger().Write() << "Generating edge-expanded graph representation";
+
+    TIMER_START(expansion);
 
     std::vector<EdgeBasedNode> node_based_edge_list;
-    unsigned number_of_edge_based_nodes = 0;
     DeallocatingVector<EdgeBasedEdge> edge_based_edge_list;
+    std::vector<QueryNode> internal_to_external_node_map;
+    auto graph_size = BuildEdgeExpandedGraph(internal_to_external_node_map, node_based_edge_list,
+                                             edge_based_edge_list);
 
-    // init node_based_edge_list, edge_based_edge_list by edgeList
-    number_of_edge_based_nodes =
-        BuildEdgeExpandedGraph(lua_state, number_of_node_based_nodes, node_based_edge_list,
-                               edge_based_edge_list, speed_profile);
-    lua_close(lua_state);
+    auto number_of_node_based_nodes = graph_size.first;
+    auto max_edge_id = graph_size.second;
 
     TIMER_STOP(expansion);
 
-    BuildRTree(node_based_edge_list);
+    SimpleLogger().Write() << "building r-tree ...";
+    TIMER_START(rtree);
 
-    RangebasedCRC32 crc32;
-    if (crc32.using_hardware())
-    {
-        SimpleLogger().Write() << "using hardware based CRC32 computation";
-    }
-    else
-    {
-        SimpleLogger().Write() << "using software based CRC32 computation";
-    }
+    FindComponents(max_edge_id, edge_based_edge_list, node_based_edge_list);
 
-    const unsigned crc32_value = crc32(node_based_edge_list);
-    node_based_edge_list.clear();
-    node_based_edge_list.shrink_to_fit();
-    SimpleLogger().Write() << "CRC32: " << crc32_value;
+    BuildRTree(node_based_edge_list, internal_to_external_node_map);
 
-    WriteNodeMapping();
+    TIMER_STOP(rtree);
 
-    /***
-     * Contracting the edge-expanded graph
-     */
+    SimpleLogger().Write() << "writing node map ...";
+    WriteNodeMapping(internal_to_external_node_map);
 
-    SimpleLogger().Write() << "initializing contractor";
-    auto contractor =
-        osrm::make_unique<Contractor>(number_of_edge_based_nodes, edge_based_edge_list);
+    // Contracting the edge-expanded graph
 
     TIMER_START(contraction);
-    contractor->Run();
+    std::vector<bool> is_core_node;
+    DeallocatingVector<QueryEdge> contracted_edge_list;
+    ContractGraph(max_edge_id, edge_based_edge_list, contracted_edge_list, is_core_node);
     TIMER_STOP(contraction);
 
     SimpleLogger().Write() << "Contraction took " << TIMER_SEC(contraction) << " sec";
 
-    DeallocatingVector<QueryEdge> contracted_edge_list;
-    contractor->GetEdges(contracted_edge_list);
-    contractor.reset();
+    std::size_t number_of_used_edges =
+        WriteContractedGraph(max_edge_id, node_based_edge_list, contracted_edge_list);
+    WriteCoreNodeMarker(std::move(is_core_node));
 
-    /***
-     * Sorting contracted edges in a way that the static query graph can read some in in-place.
-     */
+    TIMER_STOP(preparing);
 
+    SimpleLogger().Write() << "Preprocessing : " << TIMER_SEC(preparing) << " seconds";
+    SimpleLogger().Write() << "Expansion  : " << (number_of_node_based_nodes / TIMER_SEC(expansion))
+                           << " nodes/sec and " << ((max_edge_id + 1) / TIMER_SEC(expansion))
+                           << " edges/sec";
+
+    SimpleLogger().Write() << "Contraction: " << ((max_edge_id + 1) / TIMER_SEC(contraction))
+                           << " nodes/sec and " << number_of_used_edges / TIMER_SEC(contraction)
+                           << " edges/sec";
+
+    SimpleLogger().Write() << "finished preprocessing";
+
+    return 0;
+}
+
+void Prepare::FindComponents(unsigned max_edge_id,
+                             const DeallocatingVector<EdgeBasedEdge> &input_edge_list,
+                             std::vector<EdgeBasedNode> &input_nodes) const
+{
+    struct UncontractedEdgeData
+    {
+    };
+    struct InputEdge
+    {
+        unsigned source;
+        unsigned target;
+        UncontractedEdgeData data;
+
+        bool operator<(const InputEdge &rhs) const
+        {
+            return source < rhs.source || (source == rhs.source && target < rhs.target);
+        }
+
+        bool operator==(const InputEdge &rhs) const
+        {
+            return source == rhs.source && target == rhs.target;
+        }
+    };
+    using UncontractedGraph = StaticGraph<UncontractedEdgeData>;
+    std::vector<InputEdge> edges;
+    edges.reserve(input_edge_list.size() * 2);
+
+    for (const auto &edge : input_edge_list)
+    {
+        BOOST_ASSERT_MSG(static_cast<unsigned int>(std::max(edge.weight, 1)) > 0,
+                         "edge distance < 1");
+        if (edge.forward)
+        {
+            edges.push_back({edge.source, edge.target, {}});
+        }
+
+        if (edge.backward)
+        {
+            edges.push_back({edge.target, edge.source, {}});
+        }
+    }
+
+    // connect forward and backward nodes of each edge
+    for (const auto &node : input_nodes)
+    {
+        if (node.reverse_edge_based_node_id != SPECIAL_NODEID)
+        {
+            edges.push_back({node.forward_edge_based_node_id, node.reverse_edge_based_node_id, {}});
+            edges.push_back({node.reverse_edge_based_node_id, node.forward_edge_based_node_id, {}});
+        }
+    }
+
+    tbb::parallel_sort(edges.begin(), edges.end());
+    auto new_end = std::unique(edges.begin(), edges.end());
+    edges.resize(new_end - edges.begin());
+
+    auto uncontractor_graph = std::make_shared<UncontractedGraph>(max_edge_id + 1, edges);
+
+    TarjanSCC<UncontractedGraph> component_search(
+        std::const_pointer_cast<const UncontractedGraph>(uncontractor_graph));
+    component_search.run();
+
+    for (auto &node : input_nodes)
+    {
+        auto forward_component = component_search.get_component_id(node.forward_edge_based_node_id);
+        BOOST_ASSERT(node.reverse_edge_based_node_id == SPECIAL_EDGEID ||
+                     forward_component ==
+                         component_search.get_component_id(node.reverse_edge_based_node_id));
+
+        const unsigned component_size = component_search.get_component_size(forward_component);
+        const bool is_tiny_component = component_size < 1000;
+        node.component_id = is_tiny_component ? (1 + forward_component) : 0;
+    }
+}
+
+void Prepare::WriteCoreNodeMarker(std::vector<bool> &&in_is_core_node) const
+{
+    std::vector<bool> is_core_node(in_is_core_node);
+    std::vector<char> unpacked_bool_flags(is_core_node.size());
+    for (auto i = 0u; i < is_core_node.size(); ++i)
+    {
+        unpacked_bool_flags[i] = is_core_node[i] ? 1 : 0;
+    }
+
+    boost::filesystem::ofstream core_marker_output_stream(config.core_output_path,
+                                                          std::ios::binary);
+    unsigned size = unpacked_bool_flags.size();
+    core_marker_output_stream.write((char *)&size, sizeof(unsigned));
+    core_marker_output_stream.write((char *)unpacked_bool_flags.data(),
+                                    sizeof(char) * unpacked_bool_flags.size());
+}
+
+std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
+                                          const std::vector<EdgeBasedNode> &node_based_edge_list,
+                                          const DeallocatingVector<QueryEdge> &contracted_edge_list)
+{
+    const unsigned crc32_value = CalculateEdgeChecksum(node_based_edge_list);
+
+    // Sorting contracted edges in a way that the static query graph can read some in in-place.
     tbb::parallel_sort(contracted_edge_list.begin(), contracted_edge_list.end());
     const unsigned contracted_edge_count = contracted_edge_list.size();
     SimpleLogger().Write() << "Serializing compacted graph of " << contracted_edge_count
                            << " edges";
 
-    boost::filesystem::ofstream hsgr_output_stream(graph_out, std::ios::binary);
-    hsgr_output_stream.write((char *)&fingerprint_orig, sizeof(FingerPrint));
-    const unsigned max_used_node_id = 1 + [&contracted_edge_list]
+    const FingerPrint fingerprint = FingerPrint::GetValid();
+    boost::filesystem::ofstream hsgr_output_stream(config.graph_output_path, std::ios::binary);
+    hsgr_output_stream.write((char *)&fingerprint, sizeof(FingerPrint));
+    const unsigned max_used_node_id = [&contracted_edge_list]
     {
         unsigned tmp_max = 0;
         for (const QueryEdge &edge : contracted_edge_list)
@@ -226,19 +251,20 @@ int Prepare::Process(int argc, char *argv[])
         return tmp_max;
     }();
 
-    SimpleLogger().Write(logDEBUG) << "input graph has " << number_of_edge_based_nodes << " nodes";
-    SimpleLogger().Write(logDEBUG) << "contracted graph has " << max_used_node_id << " nodes";
+    SimpleLogger().Write(logDEBUG) << "input graph has " << (max_node_id + 1) << " nodes";
+    SimpleLogger().Write(logDEBUG) << "contracted graph has " << (max_used_node_id + 1) << " nodes";
 
     std::vector<StaticGraph<EdgeData>::NodeArrayEntry> node_array;
-    node_array.resize(number_of_edge_based_nodes + 1);
+    // make sure we have at least one sentinel
+    node_array.resize(max_node_id + 2);
 
     SimpleLogger().Write() << "Building node array";
     StaticGraph<EdgeData>::EdgeIterator edge = 0;
     StaticGraph<EdgeData>::EdgeIterator position = 0;
-    StaticGraph<EdgeData>::EdgeIterator last_edge = edge;
+    StaticGraph<EdgeData>::EdgeIterator last_edge;
 
     // initializing 'first_edge'-field of nodes:
-    for (const auto node : osrm::irange(0u, max_used_node_id))
+    for (const auto node : osrm::irange(0u, max_used_node_id + 1))
     {
         last_edge = edge;
         while ((edge < contracted_edge_count) && (contracted_edge_list[edge].source == node))
@@ -249,7 +275,8 @@ int Prepare::Process(int argc, char *argv[])
         position += edge - last_edge;           // remove
     }
 
-    for (const auto sentinel_counter : osrm::irange<unsigned>(max_used_node_id, node_array.size()))
+    for (const auto sentinel_counter :
+         osrm::irange<unsigned>(max_used_node_id + 1, node_array.size()))
     {
         // sentinel element, guarded against underflow
         node_array[sentinel_counter].first_edge = contracted_edge_count;
@@ -270,10 +297,9 @@ int Prepare::Process(int argc, char *argv[])
         hsgr_output_stream.write((char *)&node_array[0],
                                  sizeof(StaticGraph<EdgeData>::NodeArrayEntry) * node_array_size);
     }
-    // serialize all edges
 
+    // serialize all edges
     SimpleLogger().Write() << "Building edge array";
-    edge = 0;
     int number_of_used_edges = 0;
 
     StaticGraph<EdgeData>::EdgeArrayEntry current_edge;
@@ -285,7 +311,7 @@ int Prepare::Process(int argc, char *argv[])
         current_edge.data = contracted_edge_list[edge].data;
 
         // every target needs to be valid
-        BOOST_ASSERT(current_edge.target < max_used_node_id);
+        BOOST_ASSERT(current_edge.target <= max_used_node_id);
 #ifndef NDEBUG
         if (current_edge.data.distance <= 0)
         {
@@ -305,170 +331,53 @@ int Prepare::Process(int argc, char *argv[])
 
         ++number_of_used_edges;
     }
-    hsgr_output_stream.close();
 
-    TIMER_STOP(preparing);
-
-    SimpleLogger().Write() << "Preprocessing : " << TIMER_SEC(preparing) << " seconds";
-    SimpleLogger().Write() << "Expansion  : " << (number_of_node_based_nodes / TIMER_SEC(expansion))
-                           << " nodes/sec and "
-                           << (number_of_edge_based_nodes / TIMER_SEC(expansion)) << " edges/sec";
-
-    SimpleLogger().Write() << "Contraction: "
-                           << (number_of_edge_based_nodes / TIMER_SEC(contraction))
-                           << " nodes/sec and " << number_of_used_edges / TIMER_SEC(contraction)
-                           << " edges/sec";
-
-    node_array.clear();
-    SimpleLogger().Write() << "finished preprocessing";
-
-    return 0;
+    return number_of_used_edges;
 }
 
-/**
- \brief Parses command line arguments
- \param argc count of arguments
- \param argv array of arguments
- \param result [out] value for exit return value
- \return true if everything is ok, false if need to terminate execution
-*/
-bool Prepare::ParseArguments(int argc, char *argv[])
+unsigned Prepare::CalculateEdgeChecksum(const std::vector<EdgeBasedNode> &node_based_edge_list)
 {
-    // declare a group of options that will be allowed only on command line
-    boost::program_options::options_description generic_options("Options");
-    generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message")(
-        "config,c", boost::program_options::value<boost::filesystem::path>(&config_file_path)
-                        ->default_value("contractor.ini"),
-        "Path to a configuration file.");
-
-    // declare a group of options that will be allowed both on command line and in config file
-    boost::program_options::options_description config_options("Configuration");
-    config_options.add_options()(
-        "restrictions,r",
-        boost::program_options::value<boost::filesystem::path>(&restrictions_path),
-        "Restrictions file in .osrm.restrictions format")(
-        "profile,p", boost::program_options::value<boost::filesystem::path>(&profile_path)
-                         ->default_value("profile.lua"),
-        "Path to LUA routing profile")(
-        "threads,t", boost::program_options::value<unsigned int>(&requested_num_threads)
-                         ->default_value(tbb::task_scheduler_init::default_num_threads()),
-        "Number of threads to use");
-
-    // hidden options, will be allowed both on command line and in config file, but will not be
-    // shown to the user
-    boost::program_options::options_description hidden_options("Hidden options");
-    hidden_options.add_options()(
-        "input,i", boost::program_options::value<boost::filesystem::path>(&input_path),
-        "Input file in .osm, .osm.bz2 or .osm.pbf format");
-
-    // positional option
-    boost::program_options::positional_options_description positional_options;
-    positional_options.add("input", 1);
-
-    // combine above options for parsing
-    boost::program_options::options_description cmdline_options;
-    cmdline_options.add(generic_options).add(config_options).add(hidden_options);
-
-    boost::program_options::options_description config_file_options;
-    config_file_options.add(config_options).add(hidden_options);
-
-    boost::program_options::options_description visible_options(
-        "Usage: " + boost::filesystem::basename(argv[0]) + " <input.osrm> [options]");
-    visible_options.add(generic_options).add(config_options);
-
-    // parse command line options
-    boost::program_options::variables_map option_variables;
-    boost::program_options::store(boost::program_options::command_line_parser(argc, argv)
-                                      .options(cmdline_options)
-                                      .positional(positional_options)
-                                      .run(),
-                                  option_variables);
-
-    const auto &temp_config_path = option_variables["config"].as<boost::filesystem::path>();
-    if (boost::filesystem::is_regular_file(temp_config_path))
+    RangebasedCRC32 crc32;
+    if (crc32.using_hardware())
     {
-        boost::program_options::store(boost::program_options::parse_config_file<char>(
-                                          temp_config_path.string().c_str(), cmdline_options, true),
-                                      option_variables);
+        SimpleLogger().Write() << "using hardware based CRC32 computation";
+    }
+    else
+    {
+        SimpleLogger().Write() << "using software based CRC32 computation";
     }
 
-    if (option_variables.count("version"))
-    {
-        SimpleLogger().Write() << g_GIT_DESCRIPTION;
-        return false;
-    }
+    const unsigned crc32_value = crc32(node_based_edge_list);
+    SimpleLogger().Write() << "CRC32: " << crc32_value;
 
-    if (option_variables.count("help"))
-    {
-        SimpleLogger().Write() << "\n" << visible_options;
-        return false;
-    }
-
-    boost::program_options::notify(option_variables);
-
-    if (!option_variables.count("restrictions"))
-    {
-        restrictions_path = std::string(input_path.string() + ".restrictions");
-    }
-
-    if (!option_variables.count("input"))
-    {
-        SimpleLogger().Write() << "\n" << visible_options;
-        return false;
-    }
-
-    return true;
-}
-
-/**
- \brief Loads and checks file UUIDs
-*/
-void Prepare::CheckRestrictionsFile(FingerPrint &fingerprint_orig)
-{
-    boost::filesystem::ifstream restriction_stream(restrictions_path, std::ios::binary);
-    FingerPrint fingerprint_loaded;
-    unsigned number_of_usable_restrictions = 0;
-    restriction_stream.read((char *)&fingerprint_loaded, sizeof(FingerPrint));
-    if (!fingerprint_loaded.TestPrepare(fingerprint_orig))
-    {
-        SimpleLogger().Write(logWARNING) << ".restrictions was prepared with different build.\n"
-                                            "Reprocess to get rid of this warning.";
-    }
-
-    restriction_stream.read((char *)&number_of_usable_restrictions, sizeof(unsigned));
-    restriction_list.resize(number_of_usable_restrictions);
-    if (number_of_usable_restrictions > 0)
-    {
-        restriction_stream.read((char *)&(restriction_list[0]),
-                                number_of_usable_restrictions * sizeof(TurnRestriction));
-    }
-    restriction_stream.close();
+    return crc32_value;
 }
 
 /**
     \brief Setups scripting environment (lua-scripting)
     Also initializes speed profile.
 */
-bool Prepare::SetupScriptingEnvironment(
-    lua_State *lua_state, EdgeBasedGraphFactory::SpeedProfileProperties &speed_profile)
+void Prepare::SetupScriptingEnvironment(lua_State *lua_state, SpeedProfileProperties &speed_profile)
 {
     // open utility libraries string library;
     luaL_openlibs(lua_state);
 
     // adjust lua load path
-    luaAddScriptFolderToLoadPath(lua_state, profile_path.string().c_str());
+    luaAddScriptFolderToLoadPath(lua_state, config.profile_path.string().c_str());
 
     // Now call our function in a lua script
-    if (0 != luaL_dofile(lua_state, profile_path.string().c_str()))
+    if (0 != luaL_dofile(lua_state, config.profile_path.string().c_str()))
     {
-        std::cerr << lua_tostring(lua_state, -1) << " occured in scripting block" << std::endl;
-        return false;
+        std::stringstream msg;
+        msg << lua_tostring(lua_state, -1) << " occured in scripting block";
+        throw osrm::exception(msg.str());
     }
 
     if (0 != luaL_dostring(lua_state, "return traffic_signal_penalty\n"))
     {
-        std::cerr << lua_tostring(lua_state, -1) << " occured in scripting block" << std::endl;
-        return false;
+        std::stringstream msg;
+        msg << lua_tostring(lua_state, -1) << " occured in scripting block";
+        throw osrm::exception(msg.str());
     }
     speed_profile.traffic_signal_penalty = 10 * lua_tointeger(lua_state, -1);
     SimpleLogger().Write(logDEBUG)
@@ -476,92 +385,155 @@ bool Prepare::SetupScriptingEnvironment(
 
     if (0 != luaL_dostring(lua_state, "return u_turn_penalty\n"))
     {
-        std::cerr << lua_tostring(lua_state, -1) << " occured in scripting block" << std::endl;
-        return false;
+        std::stringstream msg;
+        msg << lua_tostring(lua_state, -1) << " occured in scripting block";
+        throw osrm::exception(msg.str());
     }
 
     speed_profile.u_turn_penalty = 10 * lua_tointeger(lua_state, -1);
     speed_profile.has_turn_penalty_function = lua_function_exists(lua_state, "turn_function");
+}
 
-    return true;
+/**
+  \brief Build load restrictions from .restriction file
+  */
+std::shared_ptr<RestrictionMap> Prepare::LoadRestrictionMap()
+{
+    boost::filesystem::ifstream input_stream(config.restrictions_path,
+                                             std::ios::in | std::ios::binary);
+
+    std::vector<TurnRestriction> restriction_list;
+    loadRestrictionsFromFile(input_stream, restriction_list);
+
+    SimpleLogger().Write() << " - " << restriction_list.size() << " restrictions.";
+
+    return std::make_shared<RestrictionMap>(restriction_list);
+}
+
+/**
+  \brief Load node based graph from .osrm file
+  */
+std::shared_ptr<NodeBasedDynamicGraph>
+Prepare::LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
+                            std::unordered_set<NodeID> &traffic_lights,
+                            std::vector<QueryNode> &internal_to_external_node_map)
+{
+    std::vector<NodeBasedEdge> edge_list;
+
+    boost::filesystem::ifstream input_stream(config.osrm_input_path,
+                                             std::ios::in | std::ios::binary);
+
+    std::vector<NodeID> barrier_list;
+    std::vector<NodeID> traffic_light_list;
+    NodeID number_of_node_based_nodes = loadNodesFromFile(
+        input_stream, barrier_list, traffic_light_list, internal_to_external_node_map);
+
+    SimpleLogger().Write() << " - " << barrier_list.size() << " bollard nodes, "
+                           << traffic_light_list.size() << " traffic lights";
+
+    // insert into unordered sets for fast lookup
+    barrier_nodes.insert(barrier_list.begin(), barrier_list.end());
+    traffic_lights.insert(traffic_light_list.begin(), traffic_light_list.end());
+
+    barrier_list.clear();
+    barrier_list.shrink_to_fit();
+    traffic_light_list.clear();
+    traffic_light_list.shrink_to_fit();
+
+    loadEdgesFromFile(input_stream, edge_list);
+
+    if (edge_list.empty())
+    {
+        SimpleLogger().Write(logWARNING) << "The input data is empty, exiting.";
+        return std::shared_ptr<NodeBasedDynamicGraph>();
+    }
+
+    return NodeBasedDynamicGraphFromEdges(number_of_node_based_nodes, edge_list);
 }
 
 /**
  \brief Building an edge-expanded graph from node-based input and turn restrictions
 */
-std::size_t
-Prepare::BuildEdgeExpandedGraph(lua_State *lua_state,
-                                NodeID number_of_node_based_nodes,
+std::pair<std::size_t, std::size_t>
+Prepare::BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,
                                 std::vector<EdgeBasedNode> &node_based_edge_list,
-                                DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
-                                EdgeBasedGraphFactory::SpeedProfileProperties &speed_profile)
+                                DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list)
 {
-    SimpleLogger().Write() << "Generating edge-expanded graph representation";
-    std::shared_ptr<NodeBasedDynamicGraph> node_based_graph =
-        NodeBasedDynamicGraphFromImportEdges(number_of_node_based_nodes, edge_list);
-    std::unique_ptr<RestrictionMap> restriction_map =
-        osrm::make_unique<RestrictionMap>(restriction_list);
-    std::shared_ptr<EdgeBasedGraphFactory> edge_based_graph_factory =
-        std::make_shared<EdgeBasedGraphFactory>(node_based_graph, std::move(restriction_map),
-                                                barrier_node_list, traffic_light_list,
-                                                internal_to_external_node_map, speed_profile);
-    edge_list.clear();
-    edge_list.shrink_to_fit();
+    lua_State *lua_state = luaL_newstate();
+    luabind::open(lua_state);
 
-    edge_based_graph_factory->Run(edge_out, geometry_filename, lua_state);
+    SpeedProfileProperties speed_profile;
+    SetupScriptingEnvironment(lua_state, speed_profile);
 
-    restriction_list.clear();
-    restriction_list.shrink_to_fit();
-    barrier_node_list.clear();
-    barrier_node_list.shrink_to_fit();
-    traffic_light_list.clear();
-    traffic_light_list.shrink_to_fit();
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
 
-    const std::size_t number_of_edge_based_nodes =
-        edge_based_graph_factory->GetNumberOfEdgeBasedNodes();
+    auto restriction_map = LoadRestrictionMap();
+    auto node_based_graph =
+        LoadNodeBasedGraph(barrier_nodes, traffic_lights, internal_to_external_node_map);
 
-    BOOST_ASSERT(number_of_edge_based_nodes != std::numeric_limits<unsigned>::max());
-#ifndef WIN32
-    static_assert(sizeof(EdgeBasedEdge) == 16,
-                  "changing ImportEdge type has influence on memory consumption!");
-#endif
+    CompressedEdgeContainer compressed_edge_container;
+    GraphCompressor graph_compressor(speed_profile);
+    graph_compressor.Compress(barrier_nodes, traffic_lights, *restriction_map, *node_based_graph,
+                              compressed_edge_container);
 
-    edge_based_graph_factory->GetEdgeBasedEdges(edge_based_edge_list);
-    edge_based_graph_factory->GetEdgeBasedNodes(node_based_edge_list);
+    EdgeBasedGraphFactory edge_based_graph_factory(
+        node_based_graph, compressed_edge_container, barrier_nodes, traffic_lights,
+        std::const_pointer_cast<RestrictionMap const>(restriction_map),
+        internal_to_external_node_map, speed_profile);
 
-    edge_based_graph_factory.reset();
-    node_based_graph.reset();
+    compressed_edge_container.SerializeInternalVector(config.geometry_output_path);
 
-    return number_of_edge_based_nodes;
+    edge_based_graph_factory.Run(config.edge_output_path, lua_state);
+    lua_close(lua_state);
+
+    edge_based_graph_factory.GetEdgeBasedEdges(edge_based_edge_list);
+    edge_based_graph_factory.GetEdgeBasedNodes(node_based_edge_list);
+    auto max_edge_id = edge_based_graph_factory.GetHighestEdgeID();
+
+    const std::size_t number_of_node_based_nodes = node_based_graph->GetNumberOfNodes();
+    return std::make_pair(number_of_node_based_nodes, max_edge_id);
+}
+
+/**
+ \brief Build contracted graph.
+ */
+void Prepare::ContractGraph(const unsigned max_edge_id,
+                            DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                            DeallocatingVector<QueryEdge> &contracted_edge_list,
+                            std::vector<bool> &is_core_node)
+{
+    Contractor contractor(max_edge_id + 1, edge_based_edge_list);
+    contractor.Run(config.core_factor);
+    contractor.GetEdges(contracted_edge_list);
+    contractor.GetCoreMarker(is_core_node);
 }
 
 /**
   \brief Writing info on original (node-based) nodes
  */
-void Prepare::WriteNodeMapping()
+void Prepare::WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map)
 {
-    SimpleLogger().Write() << "writing node map ...";
-    boost::filesystem::ofstream node_stream(node_filename, std::ios::binary);
+    boost::filesystem::ofstream node_stream(config.node_output_path, std::ios::binary);
     const unsigned size_of_mapping = internal_to_external_node_map.size();
     node_stream.write((char *)&size_of_mapping, sizeof(unsigned));
     if (size_of_mapping > 0)
     {
-        node_stream.write((char *)&(internal_to_external_node_map[0]),
+        node_stream.write((char *)internal_to_external_node_map.data(),
                           size_of_mapping * sizeof(QueryNode));
     }
     node_stream.close();
-    internal_to_external_node_map.clear();
-    internal_to_external_node_map.shrink_to_fit();
 }
 
 /**
     \brief Building rtree-based nearest-neighbor data structure
 
-    Saves info to files: '.ramIndex' and '.fileIndex'.
+    Saves tree into '.ramIndex' and leaves into '.fileIndex'.
  */
-void Prepare::BuildRTree(std::vector<EdgeBasedNode> &node_based_edge_list)
+void Prepare::BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list,
+                         const std::vector<QueryNode> &internal_to_external_node_map)
 {
-    SimpleLogger().Write() << "building r-tree ...";
-    StaticRTree<EdgeBasedNode>(node_based_edge_list, rtree_nodes_path.c_str(),
-                               rtree_leafs_path.c_str(), internal_to_external_node_map);
+    StaticRTree<EdgeBasedNode>(node_based_edge_list, config.rtree_nodes_output_path.c_str(),
+                               config.rtree_leafs_output_path.c_str(),
+                               internal_to_external_node_map);
 }

contractor/processing_chain.hpp

@@ -28,11 +28,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef PROCESSING_CHAIN_HPP
 #define PROCESSING_CHAIN_HPP
 
+#include "contractor_options.hpp"
 #include "edge_based_graph_factory.hpp"
 #include "../data_structures/query_edge.hpp"
 #include "../data_structures/static_graph.hpp"
 
-class FingerPrint;
+struct SpeedProfileProperties;
 struct EdgeBasedNode;
 struct lua_State;
 
@@ -50,46 +51,41 @@ class Prepare
     using InputEdge = DynamicGraph<EdgeData>::InputEdge;
     using StaticEdge = StaticGraph<EdgeData>::InputEdge;
 
-    explicit Prepare();
+    explicit Prepare(ContractorConfig contractor_config) : config(std::move(contractor_config)) {}
     Prepare(const Prepare &) = delete;
     ~Prepare();
 
-    int Process(int argc, char *argv[]);
+    int Run();
 
   protected:
-    bool ParseArguments(int argc, char *argv[]);
-    void CheckRestrictionsFile(FingerPrint &fingerprint_orig);
-    bool SetupScriptingEnvironment(lua_State *myLuaState,
-                                   EdgeBasedGraphFactory::SpeedProfileProperties &speed_profile);
-    std::size_t BuildEdgeExpandedGraph(lua_State *myLuaState,
-                                       NodeID nodeBasedNodeNumber,
-                                       std::vector<EdgeBasedNode> &nodeBasedEdgeList,
-                                       DeallocatingVector<EdgeBasedEdge> &edgeBasedEdgeList,
-                                       EdgeBasedGraphFactory::SpeedProfileProperties &speed_profile);
-    void WriteNodeMapping();
-    void BuildRTree(std::vector<EdgeBasedNode> &node_based_edge_list);
+    void SetupScriptingEnvironment(lua_State *myLuaState, SpeedProfileProperties &speed_profile);
+    unsigned CalculateEdgeChecksum(const std::vector<EdgeBasedNode> &node_based_edge_list);
+    void ContractGraph(const unsigned max_edge_id,
+                       DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                       DeallocatingVector<QueryEdge> &contracted_edge_list,
+                       std::vector<bool> &is_core_node);
+    void WriteCoreNodeMarker(std::vector<bool> &&is_core_node) const;
+    std::size_t WriteContractedGraph(unsigned number_of_edge_based_nodes,
+                                     const std::vector<EdgeBasedNode> &node_based_edge_list,
+                                     const DeallocatingVector<QueryEdge> &contracted_edge_list);
+    std::shared_ptr<RestrictionMap> LoadRestrictionMap();
+    std::shared_ptr<NodeBasedDynamicGraph>
+    LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
+                       std::unordered_set<NodeID> &traffic_lights,
+                       std::vector<QueryNode> &internal_to_external_node_map);
+    std::pair<std::size_t, std::size_t>
+    BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,
+                           std::vector<EdgeBasedNode> &node_based_edge_list,
+                           DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list);
+    void WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map);
+    void FindComponents(unsigned max_edge_id,
+                        const DeallocatingVector<EdgeBasedEdge> &edges,
+                        std::vector<EdgeBasedNode> &nodes) const;
+    void BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list,
+                    const std::vector<QueryNode> &internal_to_external_node_map);
 
   private:
-    std::vector<QueryNode> internal_to_external_node_map;
-    std::vector<TurnRestriction> restriction_list;
-    std::vector<NodeID> barrier_node_list;
-    std::vector<NodeID> traffic_light_list;
-    std::vector<ImportEdge> edge_list;
-
-    unsigned requested_num_threads;
-    boost::filesystem::path config_file_path;
-    boost::filesystem::path input_path;
-    boost::filesystem::path restrictions_path;
-    boost::filesystem::path preinfo_path;
-    boost::filesystem::path profile_path;
-
-    std::string node_filename;
-    std::string edge_out;
-    std::string info_out;
-    std::string geometry_filename;
-    std::string graph_out;
-    std::string rtree_nodes_path;
-    std::string rtree_leafs_path;
+    ContractorConfig config;
 };
 
 #endif // PROCESSING_CHAIN_HPP

contractor/speed_profile.hpp

@@ -0,0 +1,16 @@
+#ifndef SPEED_PROFILE_PROPERTIES_HPP
+#define SPEED_PROFILE_PROPERTIES_HPP
+
+struct SpeedProfileProperties
+{
+  SpeedProfileProperties()
+    : traffic_signal_penalty(0), u_turn_penalty(0), has_turn_penalty_function(false)
+  {
+  }
+
+  int traffic_signal_penalty;
+  int u_turn_penalty;
+  bool has_turn_penalty_function;
+};
+
+#endif

data_structures/binary_heap.hpp

@@ -189,6 +189,11 @@ class BinaryHeap
         return inserted_nodes[heap[1].index].node;
     }
 
+    Weight MinKey() const {
+      BOOST_ASSERT(heap.size() > 1);
+      return heap[1].weight;
+    }
+
     NodeID DeleteMin()
     {
         BOOST_ASSERT(heap.size() > 1);
@@ -207,7 +212,7 @@ class BinaryHeap
     void DeleteAll()
     {
         auto iend = heap.end();
-        for (typename std::vector<HeapElement>::iterator i = heap.begin() + 1; i != iend; ++i)
+        for (auto i = heap.begin() + 1; i != iend; ++i)
         {
             inserted_nodes[i->index].key = 0;
         }
@@ -232,7 +237,9 @@ class BinaryHeap
     class HeapNode
     {
       public:
-        HeapNode(NodeID n, Key k, Weight w, Data d) : node(n), key(k), weight(w), data(d) {}
+        HeapNode(NodeID n, Key k, Weight w, Data d) : node(n), key(k), weight(w), data(std::move(d))
+        {
+        }
 
         NodeID node;
         Key key;

data_structures/compressed_edge_container.cpp

@@ -25,7 +25,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#include "geometry_compressor.hpp"
+#include "compressed_edge_container.hpp"
 #include "../util/simple_logger.hpp"
 
 #include <boost/assert.hpp>
@@ -35,13 +35,15 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <limits>
 #include <string>
 
-GeometryCompressor::GeometryCompressor()
+#include <iostream>
+
+CompressedEdgeContainer::CompressedEdgeContainer()
 {
     m_free_list.reserve(100);
     IncreaseFreeList();
 }
 
-void GeometryCompressor::IncreaseFreeList()
+void CompressedEdgeContainer::IncreaseFreeList()
 {
     m_compressed_geometries.resize(m_compressed_geometries.size() + 100);
     for (unsigned i = 100; i > 0; --i)
@@ -51,13 +53,13 @@ void GeometryCompressor::IncreaseFreeList()
     }
 }
 
-bool GeometryCompressor::HasEntryForID(const EdgeID edge_id) const
+bool CompressedEdgeContainer::HasEntryForID(const EdgeID edge_id) const
 {
     auto iter = m_edge_id_to_list_index_map.find(edge_id);
     return iter != m_edge_id_to_list_index_map.end();
 }
 
-unsigned GeometryCompressor::GetPositionForID(const EdgeID edge_id) const
+unsigned CompressedEdgeContainer::GetPositionForID(const EdgeID edge_id) const
 {
     auto map_iterator = m_edge_id_to_list_index_map.find(edge_id);
     BOOST_ASSERT(map_iterator != m_edge_id_to_list_index_map.end());
@@ -65,7 +67,7 @@ unsigned GeometryCompressor::GetPositionForID(const EdgeID edge_id) const
     return map_iterator->second;
 }
 
-void GeometryCompressor::SerializeInternalVector(const std::string &path) const
+void CompressedEdgeContainer::SerializeInternalVector(const std::string &path) const
 {
 
     boost::filesystem::fstream geometry_out_stream(path, std::ios::binary | std::ios::out);
@@ -108,7 +110,7 @@ void GeometryCompressor::SerializeInternalVector(const std::string &path) const
     geometry_out_stream.close();
 }
 
-void GeometryCompressor::CompressEdge(const EdgeID edge_id_1,
+void CompressedEdgeContainer::CompressEdge(const EdgeID edge_id_1,
                                       const EdgeID edge_id_2,
                                       const NodeID via_node_id,
                                       const NodeID target_node_id,
@@ -153,6 +155,8 @@ void GeometryCompressor::CompressEdge(const EdgeID edge_id_1,
 
     std::vector<CompressedNode> &edge_bucket_list1 = m_compressed_geometries[edge_bucket_id1];
 
+    // note we don't save the start coordinate: it is implicitly given by edge 1
+    // weight1 is the distance to the (currently) last coordinate in the bucket
     if (edge_bucket_list1.empty())
     {
         edge_bucket_list1.emplace_back(via_node_id, weight1);
@@ -190,7 +194,7 @@ void GeometryCompressor::CompressEdge(const EdgeID edge_id_1,
     }
 }
 
-void GeometryCompressor::PrintStatistics() const
+void CompressedEdgeContainer::PrintStatistics() const
 {
     const uint64_t compressed_edges = m_compressed_geometries.size();
     BOOST_ASSERT(0 == compressed_edges % 2);
@@ -215,20 +219,20 @@ void GeometryCompressor::PrintStatistics() const
                                   std::max((uint64_t)1, compressed_edges);
 }
 
-const std::vector<GeometryCompressor::CompressedNode> &
-GeometryCompressor::GetBucketReference(const EdgeID edge_id) const
+const CompressedEdgeContainer::EdgeBucket&
+CompressedEdgeContainer::GetBucketReference(const EdgeID edge_id) const
 {
     const unsigned index = m_edge_id_to_list_index_map.at(edge_id);
     return m_compressed_geometries.at(index);
 }
 
-NodeID GeometryCompressor::GetFirstNodeIDOfBucket(const EdgeID edge_id) const
+NodeID CompressedEdgeContainer::GetFirstEdgeTargetID(const EdgeID edge_id) const
 {
     const auto &bucket = GetBucketReference(edge_id);
     BOOST_ASSERT(bucket.size() >= 2);
-    return bucket[1].first;
+    return bucket.front().first;
 }
-NodeID GeometryCompressor::GetLastNodeIDOfBucket(const EdgeID edge_id) const
+NodeID CompressedEdgeContainer::GetLastEdgeSourceID(const EdgeID edge_id) const
 {
     const auto &bucket = GetBucketReference(edge_id);
     BOOST_ASSERT(bucket.size() >= 2);

data_structures/compressed_edge_container.hpp

@@ -35,12 +35,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 #include <vector>
 
-class GeometryCompressor
+class CompressedEdgeContainer
 {
   public:
     using CompressedNode = std::pair<NodeID, EdgeWeight>;
+    using EdgeBucket = std::vector<CompressedNode>;
 
-    GeometryCompressor();
+    CompressedEdgeContainer();
     void CompressEdge(const EdgeID surviving_edge_id,
                       const EdgeID removed_edge_id,
                       const NodeID via_node_id,
@@ -52,16 +53,15 @@ class GeometryCompressor
     void PrintStatistics() const;
     void SerializeInternalVector(const std::string &path) const;
     unsigned GetPositionForID(const EdgeID edge_id) const;
-    const std::vector<GeometryCompressor::CompressedNode> &
-    GetBucketReference(const EdgeID edge_id) const;
-    NodeID GetFirstNodeIDOfBucket(const EdgeID edge_id) const;
-    NodeID GetLastNodeIDOfBucket(const EdgeID edge_id) const;
+    const EdgeBucket& GetBucketReference(const EdgeID edge_id) const;
+    NodeID GetFirstEdgeTargetID(const EdgeID edge_id) const;
+    NodeID GetLastEdgeSourceID(const EdgeID edge_id) const;
 
   private:
     int free_list_maximum = 0;
-    
+
     void IncreaseFreeList();
-    std::vector<std::vector<CompressedNode>> m_compressed_geometries;
+    std::vector<EdgeBucket> m_compressed_geometries;
     std::vector<unsigned> m_free_list;
     std::unordered_map<EdgeID, unsigned> m_edge_id_to_list_index_map;
 };

data_structures/coordinate.cpp

@@ -25,7 +25,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#include "coordinate_calculation.hpp"
+#include "../algorithms/coordinate_calculation.hpp"
 
 #ifndef NDEBUG
 #include "../util/simple_logger.hpp"

data_structures/deallocating_vector.hpp

@@ -36,6 +36,32 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <utility>
 #include <vector>
 
+template <typename ElementT> struct ConstDeallocatingVectorIteratorState
+{
+    ConstDeallocatingVectorIteratorState()
+        : index(std::numeric_limits<std::size_t>::max()), bucket_list(nullptr)
+    {
+    }
+    explicit ConstDeallocatingVectorIteratorState(const ConstDeallocatingVectorIteratorState &r)
+        : index(r.index), bucket_list(r.bucket_list)
+    {
+    }
+    explicit ConstDeallocatingVectorIteratorState(const std::size_t idx,
+                                             const std::vector<ElementT *> *input_list)
+        : index(idx), bucket_list(input_list)
+    {
+    }
+    std::size_t index;
+    const std::vector<ElementT *> *bucket_list;
+
+    ConstDeallocatingVectorIteratorState &operator=(const ConstDeallocatingVectorIteratorState &other)
+    {
+        index = other.index;
+        bucket_list = other.bucket_list;
+        return *this;
+    }
+};
+
 template <typename ElementT> struct DeallocatingVectorIteratorState
 {
     DeallocatingVectorIteratorState()
@@ -62,6 +88,55 @@ template <typename ElementT> struct DeallocatingVectorIteratorState
     }
 };
 
+template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK>
+class ConstDeallocatingVectorIterator
+    : public boost::iterator_facade<ConstDeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>,
+                                    ElementT,
+                                    std::random_access_iterator_tag>
+{
+    ConstDeallocatingVectorIteratorState<ElementT> current_state;
+
+  public:
+    ConstDeallocatingVectorIterator() {}
+    ConstDeallocatingVectorIterator(std::size_t idx, const std::vector<ElementT *> *input_list)
+        : current_state(idx, input_list)
+    {
+    }
+
+    friend class boost::iterator_core_access;
+
+    void advance(std::size_t n) { current_state.index += n; }
+
+    void increment() { advance(1); }
+
+    void decrement() { advance(-1); }
+
+    bool equal(ConstDeallocatingVectorIterator const &other) const
+    {
+        return current_state.index == other.current_state.index;
+    }
+
+    std::ptrdiff_t distance_to(ConstDeallocatingVectorIterator const &other) const
+    {
+        // it is important to implement it 'other minus this'. otherwise sorting breaks
+        return other.current_state.index - current_state.index;
+    }
+
+    ElementT &dereference() const
+    {
+        const std::size_t current_bucket = current_state.index / ELEMENTS_PER_BLOCK;
+        const std::size_t current_index = current_state.index % ELEMENTS_PER_BLOCK;
+        return (current_state.bucket_list->at(current_bucket)[current_index]);
+    }
+
+    ElementT &operator[](const std::size_t index) const
+    {
+        const std::size_t current_bucket = (index + current_state.index) / ELEMENTS_PER_BLOCK;
+        const std::size_t current_index = (index + current_state.index) % ELEMENTS_PER_BLOCK;
+        return (current_state.bucket_list->at(current_bucket)[current_index]);
+    }
+};
+
 template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK>
 class DeallocatingVectorIterator
     : public boost::iterator_facade<DeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>,
@@ -170,7 +245,7 @@ class DeallocatingVector
 
   public:
     using iterator = DeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>;
-    using const_iterator = DeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>;
+    using const_iterator = ConstDeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>;
 
     // this forward-only iterator deallocates all buckets that have been visited
     using deallocation_iterator = DeallocatingVectorRemoveIterator<ElementT, ELEMENTS_PER_BLOCK>;

data_structures/dynamic_graph.hpp

@@ -85,11 +85,16 @@ template <typename EdgeDataT> class DynamicGraph
         edge_list.resize(number_of_nodes);
     }
 
+    /**
+     * Constructs a DynamicGraph from a list of edges sorted by source node id.
+     */
     template <class ContainerT> DynamicGraph(const NodeIterator nodes, const ContainerT &graph)
     {
+        // we need to cast here because DeallocatingVector does not have a valid const iterator
+        BOOST_ASSERT(std::is_sorted(const_cast<ContainerT&>(graph).begin(), const_cast<ContainerT&>(graph).end()));
+
         number_of_nodes = nodes;
         number_of_edges = static_cast<EdgeIterator>(graph.size());
-        // node_array.reserve(number_of_nodes + 1);
         node_array.resize(number_of_nodes + 1);
         EdgeIterator edge = 0;
         EdgeIterator position = 0;
@@ -114,6 +119,7 @@ template <typename EdgeDataT> class DynamicGraph
                                              node_array[node].first_edge + node_array[node].edges))
             {
                 edge_list[i].target = graph[edge].target;
+                BOOST_ASSERT(edge_list[i].target < number_of_nodes);
                 edge_list[i].data = graph[edge].data;
                 ++edge;
             }
@@ -133,7 +139,7 @@ template <typename EdgeDataT> class DynamicGraph
         unsigned degree = 0;
         for (const auto edge : osrm::irange(BeginEdges(n), EndEdges(n)))
         {
-            if (GetEdgeData(edge).forward)
+            if (!GetEdgeData(edge).reversed)
             {
                 ++degree;
             }

data_structures/edge_based_node.hpp

@@ -37,6 +37,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <limits>
 
+/// This is what StaticRTree serialized and stores on disk
+/// It is generated in EdgeBasedGraphFactory.
 struct EdgeBasedNode
 {
     EdgeBasedNode()

data_structures/hidden_markov_model.hpp

@@ -91,13 +91,24 @@ template <class CandidateLists> struct HiddenMarkovModel
         : breakage(candidates_list.size()), candidates_list(candidates_list),
           emission_log_probability(emission_log_probability)
     {
-        for (const auto &l : candidates_list)
+        viterbi.resize(candidates_list.size());
+        parents.resize(candidates_list.size());
+        path_lengths.resize(candidates_list.size());
+        suspicious.resize(candidates_list.size());
+        pruned.resize(candidates_list.size());
+        breakage.resize(candidates_list.size());
+        for (const auto i : osrm::irange<std::size_t>(0u, candidates_list.size()))
         {
-            viterbi.emplace_back(l.size());
-            parents.emplace_back(l.size());
-            path_lengths.emplace_back(l.size());
-            suspicious.emplace_back(l.size());
-            pruned.emplace_back(l.size());
+            const auto& num_candidates = candidates_list[i].size();
+            // add empty vectors
+            if (num_candidates > 0)
+            {
+                viterbi[i].resize(num_candidates);
+                parents[i].resize(num_candidates);
+                path_lengths[i].resize(num_candidates);
+                suspicious[i].resize(num_candidates);
+                pruned[i].resize(num_candidates);
+            }
         }
 
         clear(0);
@@ -121,10 +132,11 @@ template <class CandidateLists> struct HiddenMarkovModel
 
     std::size_t initialize(std::size_t initial_timestamp)
     {
-        BOOST_ASSERT(initial_timestamp < candidates_list.size());
-
+        auto num_points = candidates_list.size();
         do
         {
+            BOOST_ASSERT(initial_timestamp < num_points);
+
             for (const auto s : osrm::irange<std::size_t>(0u, viterbi[initial_timestamp].size()))
             {
                 viterbi[initial_timestamp][s] =
@@ -139,9 +151,9 @@ template <class CandidateLists> struct HiddenMarkovModel
             }
 
             ++initial_timestamp;
-        } while (breakage[initial_timestamp - 1]);
+        } while (initial_timestamp < num_points && breakage[initial_timestamp - 1]);
 
-        if (initial_timestamp >= viterbi.size())
+        if (initial_timestamp >= num_points)
         {
             return osrm::matching::INVALID_STATE;
         }

data_structures/hilbert_value.cpp

@@ -57,7 +57,7 @@ uint64_t HilbertCode::BitInterleaving(const uint32_t latitude, const uint32_t lo
 
 void HilbertCode::TransposeCoordinate(uint32_t *X) const
 {
-    uint32_t M = 1 << (32 - 1), P, Q, t;
+    uint32_t M = 1u << (32 - 1), P, Q, t;
     int i;
     // Inverse undo
     for (Q = M; Q > 1; Q >>= 1)

data_structures/import_edge.cpp

@@ -47,6 +47,13 @@ bool NodeBasedEdge::operator<(const NodeBasedEdge &other) const
     return source < other.source;
 }
 
+NodeBasedEdge::NodeBasedEdge()
+    : source(SPECIAL_NODEID), target(SPECIAL_NODEID), name_id(0), weight(0), forward(false),
+      backward(false), roundabout(false),
+      access_restricted(false), is_split(false), travel_mode(false)
+{
+}
+
 NodeBasedEdge::NodeBasedEdge(NodeID source,
                              NodeID target,
                              NodeID name_id,
@@ -54,12 +61,11 @@ NodeBasedEdge::NodeBasedEdge(NodeID source,
                              bool forward,
                              bool backward,
                              bool roundabout,
-                             bool in_tiny_cc,
                              bool access_restricted,
                              TravelMode travel_mode,
                              bool is_split)
     : source(source), target(target), name_id(name_id), weight(weight), forward(forward),
-      backward(backward), roundabout(roundabout), in_tiny_cc(in_tiny_cc),
+      backward(backward), roundabout(roundabout),
       access_restricted(access_restricted), is_split(is_split), travel_mode(travel_mode)
 {
 }

data_structures/import_edge.hpp

@@ -35,6 +35,7 @@ struct NodeBasedEdge
 {
     bool operator<(const NodeBasedEdge &e) const;
 
+    NodeBasedEdge();
     explicit NodeBasedEdge(NodeID source,
                            NodeID target,
                            NodeID name_id,
@@ -42,7 +43,6 @@ struct NodeBasedEdge
                            bool forward,
                            bool backward,
                            bool roundabout,
-                           bool in_tiny_cc,
                            bool access_restricted,
                            TravelMode travel_mode,
                            bool is_split);
@@ -54,12 +54,9 @@ struct NodeBasedEdge
     bool forward : 1;
     bool backward : 1;
     bool roundabout : 1;
-    bool in_tiny_cc : 1;
     bool access_restricted : 1;
     bool is_split : 1;
     TravelMode travel_mode : 4;
-
-    NodeBasedEdge() = delete;
 };
 
 struct EdgeBasedEdge
@@ -86,6 +83,4 @@ struct EdgeBasedEdge
     bool backward : 1;
 };
 
-using ImportEdge = NodeBasedEdge;
-
 #endif /* IMPORT_EDGE_HPP */

data_structures/matrix_graph_wrapper.hpp

@@ -0,0 +1,70 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef MATRIX_GRAPH_WRAPPER_H
+#define MATRIX_GRAPH_WRAPPER_H
+
+#include <vector>
+#include <cstddef>
+#include <iterator>
+
+#include "../typedefs.h"
+
+// This Wrapper provides all methods that are needed for TarjanSCC, when the graph is given in a
+// matrix representation (e.g. as output from a distance table call)
+
+template <typename T> class MatrixGraphWrapper
+{
+  public:
+    MatrixGraphWrapper(std::vector<T> table, const std::size_t number_of_nodes)
+        : table_(std::move(table)), number_of_nodes_(number_of_nodes){};
+
+    std::size_t GetNumberOfNodes() const { return number_of_nodes_; }
+
+    std::vector<T> GetAdjacentEdgeRange(const NodeID node) const
+    {
+
+        std::vector<T> edges;
+        // find all valid adjacent edges and move to vector `edges`
+        for (std::size_t i = 0; i < number_of_nodes_; ++i)
+        {
+            if (*(std::begin(table_) + node * number_of_nodes_ + i) != INVALID_EDGE_WEIGHT)
+            {
+                edges.push_back(i);
+            }
+        }
+        return edges;
+    }
+
+    EdgeWeight GetTarget(const EdgeWeight edge) const { return edge; }
+
+  private:
+    const std::vector<T> table_;
+    const std::size_t number_of_nodes_;
+};
+
+#endif // MATRIX_GRAPH_WRAPPER_H

data_structures/node_based_graph.hpp

@@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "dynamic_graph.hpp"
 #include "import_edge.hpp"
-#include "../util/simple_logger.hpp"
+#include "../util/graph_utils.hpp"
 
 #include <tbb/parallel_sort.h>
 
@@ -39,240 +39,62 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 struct NodeBasedEdgeData
 {
     NodeBasedEdgeData()
-        : distance(INVALID_EDGE_WEIGHT), edgeBasedNodeID(SPECIAL_NODEID),
-          nameID(std::numeric_limits<unsigned>::max()), isAccessRestricted(false), shortcut(false),
-          forward(false), backward(false), roundabout(false), ignore_in_grid(false),
-          travel_mode(TRAVEL_MODE_INACCESSIBLE)
+        : distance(INVALID_EDGE_WEIGHT), edge_id(SPECIAL_NODEID),
+          name_id(std::numeric_limits<unsigned>::max()), access_restricted(false),
+          reversed(false), roundabout(false), travel_mode(TRAVEL_MODE_INACCESSIBLE)
+    {
+    }
+
+    NodeBasedEdgeData(int distance, unsigned edge_id, unsigned name_id,
+            bool access_restricted, bool reversed,
+            bool roundabout, TravelMode travel_mode)
+        : distance(distance), edge_id(edge_id), name_id(name_id),
+          access_restricted(access_restricted), reversed(reversed),
+          roundabout(roundabout), travel_mode(travel_mode)
     {
     }
 
     int distance;
-    unsigned edgeBasedNodeID;
-    unsigned nameID;
-    bool isAccessRestricted : 1;
-    bool shortcut : 1;
-    bool forward : 1;
-    bool backward : 1;
+    unsigned edge_id;
+    unsigned name_id;
+    bool access_restricted : 1;
+    bool reversed : 1;
     bool roundabout : 1;
-    bool ignore_in_grid : 1;
     TravelMode travel_mode : 4;
 
-    void SwapDirectionFlags()
+    bool IsCompatibleTo(const NodeBasedEdgeData &other) const
     {
-        bool temp_flag = forward;
-        forward = backward;
-        backward = temp_flag;
-    }
-
-    bool IsEqualTo(const NodeBasedEdgeData &other) const
-    {
-        return (forward == other.forward) && (backward == other.backward) &&
-               (nameID == other.nameID) && (ignore_in_grid == other.ignore_in_grid) &&
+        return (reversed == other.reversed) && (name_id == other.name_id) &&
                (travel_mode == other.travel_mode);
     }
 };
 
-struct SimpleEdgeData
-{
-    SimpleEdgeData() : capacity(0) {}
-    EdgeWeight capacity;
-};
-
 using NodeBasedDynamicGraph = DynamicGraph<NodeBasedEdgeData>;
-using SimpleNodeBasedDynamicGraph = DynamicGraph<SimpleEdgeData>;
 
-// Factory method to create NodeBasedDynamicGraph from ImportEdges
+/// Factory method to create NodeBasedDynamicGraph from NodeBasedEdges
+/// The since DynamicGraph expects directed edges, we need to insert
+/// two edges for undirected edges.
 inline std::shared_ptr<NodeBasedDynamicGraph>
-NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<ImportEdge> &input_edge_list)
+NodeBasedDynamicGraphFromEdges(int number_of_nodes, const std::vector<NodeBasedEdge> &input_edge_list)
 {
-    static_assert(sizeof(NodeBasedEdgeData) == 16,
-                  "changing node based edge data size changes memory consumption");
-
-    DeallocatingVector<NodeBasedDynamicGraph::InputEdge> edges_list;
-    NodeBasedDynamicGraph::InputEdge edge;
-    for (const ImportEdge &import_edge : input_edge_list)
-    {
-        if (import_edge.forward)
+    auto edges_list = directedEdgesFromCompressed<NodeBasedDynamicGraph::InputEdge>(input_edge_list,
+        [](NodeBasedDynamicGraph::InputEdge& output_edge, const NodeBasedEdge& input_edge)
         {
-            edge.source = import_edge.source;
-            edge.target = import_edge.target;
-            edge.data.forward = import_edge.forward;
-            edge.data.backward = import_edge.backward;
-        }
-        else
-        {
-            edge.source = import_edge.target;
-            edge.target = import_edge.source;
-            edge.data.backward = import_edge.forward;
-            edge.data.forward = import_edge.backward;
+            output_edge.data.distance = static_cast<int>(input_edge.weight);
+            BOOST_ASSERT(output_edge.data.distance > 0);
+
+            output_edge.data.roundabout = input_edge.roundabout;
+            output_edge.data.name_id = input_edge.name_id;
+            output_edge.data.access_restricted = input_edge.access_restricted;
+            output_edge.data.travel_mode = input_edge.travel_mode;
         }
+    );
 
-        if (edge.source == edge.target)
-        {
-            continue;
-        }
-
-        edge.data.distance = (std::max)(static_cast<int>(import_edge.weight), 1);
-        BOOST_ASSERT(edge.data.distance > 0);
-        edge.data.shortcut = false;
-        edge.data.roundabout = import_edge.roundabout;
-        edge.data.ignore_in_grid = import_edge.in_tiny_cc;
-        edge.data.nameID = import_edge.name_id;
-        edge.data.isAccessRestricted = import_edge.access_restricted;
-        edge.data.travel_mode = import_edge.travel_mode;
-
-        edges_list.push_back(edge);
-
-        if (!import_edge.is_split)
-        {
-            using std::swap; // enable ADL
-            swap(edge.source, edge.target);
-            edge.data.SwapDirectionFlags();
-            edges_list.push_back(edge);
-        }
-    }
-
-    // remove duplicate edges
     tbb::parallel_sort(edges_list.begin(), edges_list.end());
-    NodeID edge_count = 0;
-    for (NodeID i = 0; i < edges_list.size();)
-    {
-        const NodeID source = edges_list[i].source;
-        const NodeID target = edges_list[i].target;
-        // remove eigenloops
-        if (source == target)
-        {
-            i++;
-            continue;
-        }
-        NodeBasedDynamicGraph::InputEdge forward_edge;
-        NodeBasedDynamicGraph::InputEdge reverse_edge;
-        forward_edge = reverse_edge = edges_list[i];
-        forward_edge.data.forward = reverse_edge.data.backward = true;
-        forward_edge.data.backward = reverse_edge.data.forward = false;
-        forward_edge.data.shortcut = reverse_edge.data.shortcut = false;
-        forward_edge.data.distance = reverse_edge.data.distance = std::numeric_limits<int>::max();
-        // remove parallel edges
-        while (i < edges_list.size() && edges_list[i].source == source &&
-               edges_list[i].target == target)
-        {
-            if (edges_list[i].data.forward)
-            {
-                forward_edge.data.distance =
-                    std::min(edges_list[i].data.distance, forward_edge.data.distance);
-            }
-            if (edges_list[i].data.backward)
-            {
-                reverse_edge.data.distance =
-                    std::min(edges_list[i].data.distance, reverse_edge.data.distance);
-            }
-            ++i;
-        }
-        // merge edges (s,t) and (t,s) into bidirectional edge
-        if (forward_edge.data.distance == reverse_edge.data.distance)
-        {
-            if (static_cast<int>(forward_edge.data.distance) != std::numeric_limits<int>::max())
-            {
-                forward_edge.data.backward = true;
-                edges_list[edge_count++] = forward_edge;
-            }
-        }
-        else
-        { // insert seperate edges
-            if (static_cast<int>(forward_edge.data.distance) != std::numeric_limits<int>::max())
-            {
-                edges_list[edge_count++] = forward_edge;
-            }
-            if (static_cast<int>(reverse_edge.data.distance) != std::numeric_limits<int>::max())
-            {
-                edges_list[edge_count++] = reverse_edge;
-            }
-        }
-    }
-    edges_list.resize(edge_count);
-    SimpleLogger().Write() << "merged " << edges_list.size() - edge_count << " edges out of "
-                           << edges_list.size();
 
     auto graph = std::make_shared<NodeBasedDynamicGraph>(
         static_cast<NodeBasedDynamicGraph::NodeIterator>(number_of_nodes), edges_list);
-    return graph;
-}
 
-template <class SimpleEdgeT>
-inline std::shared_ptr<SimpleNodeBasedDynamicGraph>
-SimpleNodeBasedDynamicGraphFromEdges(int number_of_nodes, std::vector<SimpleEdgeT> &input_edge_list)
-{
-    static_assert(sizeof(NodeBasedEdgeData) == 16,
-                  "changing node based edge data size changes memory consumption");
-    tbb::parallel_sort(input_edge_list.begin(), input_edge_list.end());
-
-    DeallocatingVector<SimpleNodeBasedDynamicGraph::InputEdge> edges_list;
-    SimpleNodeBasedDynamicGraph::InputEdge edge;
-    edge.data.capacity = 1;
-    for (const SimpleEdgeT &import_edge : input_edge_list)
-    {
-        if (import_edge.source == import_edge.target)
-        {
-            continue;
-        }
-        edge.source = import_edge.source;
-        edge.target = import_edge.target;
-        edges_list.push_back(edge);
-        std::swap(edge.source, edge.target);
-        edges_list.push_back(edge);
-    }
-
-    // remove duplicate edges
-    tbb::parallel_sort(edges_list.begin(), edges_list.end());
-    NodeID edge_count = 0;
-    for (NodeID i = 0; i < edges_list.size();)
-    {
-        const NodeID source = edges_list[i].source;
-        const NodeID target = edges_list[i].target;
-        // remove eigenloops
-        if (source == target)
-        {
-            i++;
-            continue;
-        }
-        SimpleNodeBasedDynamicGraph::InputEdge forward_edge;
-        SimpleNodeBasedDynamicGraph::InputEdge reverse_edge;
-        forward_edge = reverse_edge = edges_list[i];
-        forward_edge.data.capacity = reverse_edge.data.capacity = INVALID_EDGE_WEIGHT;
-        // remove parallel edges
-        while (i < edges_list.size() && edges_list[i].source == source &&
-               edges_list[i].target == target)
-        {
-            forward_edge.data.capacity =
-                std::min(edges_list[i].data.capacity, forward_edge.data.capacity);
-            reverse_edge.data.capacity =
-                std::min(edges_list[i].data.capacity, reverse_edge.data.capacity);
-            ++i;
-        }
-        // merge edges (s,t) and (t,s) into bidirectional edge
-        if (forward_edge.data.capacity == reverse_edge.data.capacity)
-        {
-            if (static_cast<int>(forward_edge.data.capacity) != INVALID_EDGE_WEIGHT)
-            {
-                edges_list[edge_count++] = forward_edge;
-            }
-        }
-        else
-        { // insert seperate edges
-            if (static_cast<int>(forward_edge.data.capacity) != INVALID_EDGE_WEIGHT)
-            {
-                edges_list[edge_count++] = forward_edge;
-            }
-            if (static_cast<int>(reverse_edge.data.capacity) != INVALID_EDGE_WEIGHT)
-            {
-                edges_list[edge_count++] = reverse_edge;
-            }
-        }
-    }
-    SimpleLogger().Write() << "merged " << edges_list.size() - edge_count << " edges out of "
-                           << edges_list.size();
-
-    auto graph = std::make_shared<SimpleNodeBasedDynamicGraph>(number_of_nodes, edges_list);
     return graph;
 }
 

data_structures/phantom_node.hpp

@@ -88,8 +88,10 @@ struct PhantomNode
     unsigned component_id;
     FixedPointCoordinate location;
     unsigned short fwd_segment_position;
-    TravelMode forward_travel_mode : 4;
-    TravelMode backward_travel_mode : 4;
+    // note 4 bits would suffice for each,
+    // but the saved byte would be padding anyway
+    TravelMode forward_travel_mode;
+    TravelMode backward_travel_mode;
 
     int GetForwardWeightPlusOffset() const;
 
@@ -108,6 +110,8 @@ struct PhantomNode
     bool operator==(const PhantomNode &other) const;
 };
 
+static_assert(sizeof(PhantomNode) == 48, "PhantomNode has more padding then expected");
+
 using PhantomNodeArray = std::vector<std::vector<PhantomNode>>;
 
 class phantom_node_pair : public std::pair<PhantomNode, PhantomNode>

data_structures/query_edge.hpp

@@ -58,7 +58,7 @@ struct QueryEdge
     QueryEdge() : source(SPECIAL_NODEID), target(SPECIAL_NODEID) {}
 
     QueryEdge(NodeID source, NodeID target, EdgeData data)
-        : source(source), target(target), data(data)
+        : source(source), target(target), data(std::move(data))
     {
     }
 

data_structures/raster_source.cpp

@@ -0,0 +1,178 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "raster_source.hpp"
+
+#include "../util/simple_logger.hpp"
+#include "../util/timing_util.hpp"
+
+#include <osrm/coordinate.hpp>
+
+#include <cmath>
+
+RasterSource::RasterSource(RasterGrid _raster_data,
+                           std::size_t _width,
+                           std::size_t _height,
+                           int _xmin,
+                           int _xmax,
+                           int _ymin,
+                           int _ymax)
+    : xstep(calcSize(_xmin, _xmax, _width)), ystep(calcSize(_ymin, _ymax, _height)),
+      raster_data(_raster_data), width(_width), height(_height), xmin(_xmin), xmax(_xmax),
+      ymin(_ymin), ymax(_ymax)
+{
+    BOOST_ASSERT(xstep != 0);
+    BOOST_ASSERT(ystep != 0);
+}
+
+float RasterSource::calcSize(int min, int max, std::size_t count) const
+{
+    BOOST_ASSERT(count > 0);
+    return (max - min) / (static_cast<float>(count) - 1);
+}
+
+// Query raster source for nearest data point
+RasterDatum RasterSource::getRasterData(const int lon, const int lat) const
+{
+    if (lon < xmin || lon > xmax || lat < ymin || lat > ymax)
+    {
+        return {};
+    }
+
+    const std::size_t xth = static_cast<std::size_t>(round((lon - xmin) / xstep));
+    const std::size_t yth = static_cast<std::size_t>(round((ymax - lat) / ystep));
+
+    return {raster_data(xth, yth)};
+}
+
+// Query raster source using bilinear interpolation
+RasterDatum RasterSource::getRasterInterpolate(const int lon, const int lat) const
+{
+    if (lon < xmin || lon > xmax || lat < ymin || lat > ymax)
+    {
+        return {};
+    }
+
+    const auto xthP = (lon - xmin) / xstep;
+    const auto ythP = (ymax - lat) / ystep;
+
+    const std::size_t top = static_cast<std::size_t>(fmax(floor(ythP), 0));
+    const std::size_t bottom = static_cast<std::size_t>(fmin(ceil(ythP), height - 1));
+    const std::size_t left = static_cast<std::size_t>(fmax(floor(xthP), 0));
+    const std::size_t right = static_cast<std::size_t>(fmin(ceil(xthP), width - 1));
+
+    // Calculate distances from corners for bilinear interpolation
+    const float fromLeft = (lon - left * xstep + xmin) / xstep;
+    const float fromTop = (ymax - top * ystep - lat) / ystep;
+    const float fromRight = 1 - fromLeft;
+    const float fromBottom = 1 - fromTop;
+
+    return {static_cast<std::int32_t>(raster_data(left, top) * (fromRight * fromBottom) +
+                                      raster_data(right, top) * (fromLeft * fromBottom) +
+                                      raster_data(left, bottom) * (fromRight * fromTop) +
+                                      raster_data(right, bottom) * (fromLeft * fromTop))};
+}
+
+// Load raster source into memory
+int SourceContainer::loadRasterSource(const std::string &path_string,
+                                      double xmin,
+                                      double xmax,
+                                      double ymin,
+                                      double ymax,
+                                      std::size_t nrows,
+                                      std::size_t ncols)
+{
+    const auto _xmin = static_cast<int>(xmin * COORDINATE_PRECISION);
+    const auto _xmax = static_cast<int>(xmax * COORDINATE_PRECISION);
+    const auto _ymin = static_cast<int>(ymin * COORDINATE_PRECISION);
+    const auto _ymax = static_cast<int>(ymax * COORDINATE_PRECISION);
+
+    const auto itr = LoadedSourcePaths.find(path_string);
+    if (itr != LoadedSourcePaths.end())
+    {
+        SimpleLogger().Write() << "[source loader] Already loaded source '" << path_string
+                               << "' at source_id " << itr->second;
+        return itr->second;
+    }
+
+    int source_id = static_cast<int>(LoadedSources.size());
+
+    SimpleLogger().Write() << "[source loader] Loading from " << path_string << "  ... ";
+    TIMER_START(loading_source);
+
+    boost::filesystem::path filepath(path_string);
+    if (!boost::filesystem::exists(filepath))
+    {
+        throw osrm::exception("error reading: no such path");
+    }
+
+    RasterGrid rasterData{filepath, ncols, nrows};
+
+    RasterSource source{std::move(rasterData), ncols, nrows, _xmin, _xmax, _ymin, _ymax};
+    TIMER_STOP(loading_source);
+    LoadedSourcePaths.emplace(path_string, source_id);
+    LoadedSources.push_back(std::move(source));
+
+    SimpleLogger().Write() << "[source loader] ok, after " << TIMER_SEC(loading_source) << "s";
+
+    return source_id;
+}
+
+// External function for looking up nearest data point from a specified source
+RasterDatum SourceContainer::getRasterDataFromSource(unsigned int source_id, int lon, int lat)
+{
+    if (LoadedSources.size() < source_id + 1)
+    {
+        throw osrm::exception("error reading: no such loaded source");
+    }
+
+    BOOST_ASSERT(lat < (90 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lat > (-90 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lon < (180 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lon > (-180 * COORDINATE_PRECISION));
+
+    const auto &found = LoadedSources[source_id];
+    return found.getRasterData(lon, lat);
+}
+
+// External function for looking up interpolated data from a specified source
+RasterDatum
+SourceContainer::getRasterInterpolateFromSource(unsigned int source_id, int lon, int lat)
+{
+    if (LoadedSources.size() < source_id + 1)
+    {
+        throw osrm::exception("error reading: no such loaded source");
+    }
+
+    BOOST_ASSERT(lat < (90 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lat > (-90 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lon < (180 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lon > (-180 * COORDINATE_PRECISION));
+
+    const auto &found = LoadedSources[source_id];
+    return found.getRasterInterpolate(lon, lat);
+}

data_structures/raster_source.hpp

@@ -0,0 +1,175 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef RASTER_SOURCE_HPP
+#define RASTER_SOURCE_HPP
+
+#include "../util/osrm_exception.hpp"
+
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/spirit/include/qi_int.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/assert.hpp>
+
+#include <unordered_map>
+#include <iterator>
+
+/**
+    \brief Small wrapper around raster source queries to optionally provide results
+    gracefully, depending on source bounds
+*/
+struct RasterDatum
+{
+    static std::int32_t get_invalid() { return std::numeric_limits<std::int32_t>::max(); }
+
+    std::int32_t datum = get_invalid();
+
+    RasterDatum() = default;
+
+    RasterDatum(std::int32_t _datum) : datum(_datum) {}
+};
+
+class RasterGrid
+{
+  public:
+    RasterGrid(const boost::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
+    {
+        xdim = _xdim;
+        ydim = _ydim;
+        _data.reserve(ydim * xdim);
+
+        boost::filesystem::ifstream stream(filepath);
+        if (!stream)
+        {
+            throw osrm::exception("Unable to open raster file.");
+        }
+
+        stream.seekg(0, std::ios_base::end);
+        std::string buffer;
+        buffer.resize(static_cast<std::size_t>(stream.tellg()));
+
+        stream.seekg(0, std::ios_base::beg);
+
+        BOOST_ASSERT(buffer.size() > 1);
+        stream.read(&buffer[0], static_cast<std::streamsize>(buffer.size()));
+
+        boost::algorithm::trim(buffer);
+
+        auto itr = buffer.begin();
+        auto end = buffer.end();
+
+        bool r = false;
+        try
+        {
+            r = boost::spirit::qi::parse(
+                itr, end, +boost::spirit::qi::int_ % +boost::spirit::qi::space, _data);
+        }
+        catch (std::exception const &ex)
+        {
+            throw osrm::exception(
+                std::string("Failed to read from raster source with exception: ") + ex.what());
+        }
+
+        if (!r || itr != end)
+        {
+            throw osrm::exception("Failed to parse raster source correctly.");
+        }
+    }
+
+    RasterGrid(const RasterGrid &) = default;
+    RasterGrid &operator=(const RasterGrid &) = default;
+
+    RasterGrid(RasterGrid &&) = default;
+    RasterGrid &operator=(RasterGrid &&) = default;
+
+    std::int32_t operator()(std::size_t x, std::size_t y) { return _data[y * xdim + x]; }
+    std::int32_t operator()(std::size_t x, std::size_t y) const { return _data[(y)*xdim + (x)]; }
+
+  private:
+    std::vector<std::int32_t> _data;
+    std::size_t xdim, ydim;
+};
+
+/**
+    \brief Stores raster source data in memory and provides lookup functions.
+*/
+class RasterSource
+{
+  private:
+    const float xstep;
+    const float ystep;
+
+    float calcSize(int min, int max, std::size_t count) const;
+
+  public:
+    RasterGrid raster_data;
+
+    const std::size_t width;
+    const std::size_t height;
+    const int xmin;
+    const int xmax;
+    const int ymin;
+    const int ymax;
+
+    RasterDatum getRasterData(const int lon, const int lat) const;
+
+    RasterDatum getRasterInterpolate(const int lon, const int lat) const;
+
+    RasterSource(RasterGrid _raster_data,
+                 std::size_t width,
+                 std::size_t height,
+                 int _xmin,
+                 int _xmax,
+                 int _ymin,
+                 int _ymax);
+};
+
+class SourceContainer
+{
+  public:
+    SourceContainer() = default;
+
+    int loadRasterSource(const std::string &path_string,
+                         double xmin,
+                         double xmax,
+                         double ymin,
+                         double ymax,
+                         std::size_t nrows,
+                         std::size_t ncols);
+
+    RasterDatum getRasterDataFromSource(unsigned int source_id, int lon, int lat);
+
+    RasterDatum getRasterInterpolateFromSource(unsigned int source_id, int lon, int lat);
+
+  private:
+    std::vector<RasterSource> LoadedSources;
+    std::unordered_map<std::string, int> LoadedSourcePaths;
+};
+
+#endif /* RASTER_SOURCE_HPP */

data_structures/rectangle.hpp

@@ -28,7 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef RECTANGLE_HPP
 #define RECTANGLE_HPP
 
-#include "coordinate_calculation.hpp"
+#include "../algorithms/coordinate_calculation.hpp"
 
 #include <boost/assert.hpp>
 

data_structures/restriction_map.hpp

@@ -91,6 +91,7 @@ template <> struct hash<RestrictionTarget>
 class RestrictionMap
 {
   public:
+    RestrictionMap() : m_count(0) {};
     RestrictionMap(const std::vector<TurnRestriction> &restriction_list);
 
     // Replace end v with w in each turn restriction containing u as via node
@@ -98,7 +99,7 @@ class RestrictionMap
     void FixupArrivingTurnRestriction(const NodeID node_u,
                                       const NodeID node_v,
                                       const NodeID node_w,
-                                      const std::shared_ptr<GraphT> &graph)
+                                      const GraphT &graph)
     {
         BOOST_ASSERT(node_u != SPECIAL_NODEID);
         BOOST_ASSERT(node_v != SPECIAL_NODEID);
@@ -112,9 +113,9 @@ class RestrictionMap
         // find all potential start edges. It is more efficent to get a (small) list
         // of potential start edges than iterating over all buckets
         std::vector<NodeID> predecessors;
-        for (const EdgeID current_edge_id : graph->GetAdjacentEdgeRange(node_u))
+        for (const EdgeID current_edge_id : graph.GetAdjacentEdgeRange(node_u))
         {
-            const NodeID target = graph->GetTarget(current_edge_id);
+            const NodeID target = graph.GetTarget(current_edge_id);
             if (node_v != target)
             {
                 predecessors.push_back(target);
@@ -155,7 +156,7 @@ class RestrictionMap
     bool
     CheckIfTurnIsRestricted(const NodeID node_u, const NodeID node_v, const NodeID node_w) const;
 
-    std::size_t size() { return m_count; }
+    std::size_t size() const { return m_count; }
 
   private:
     // check of node is the start of any restriction

data_structures/route_parameters.cpp

@@ -31,10 +31,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <osrm/route_parameters.hpp>
 
+#include "../algorithms/polyline_compressor.hpp"
+
 RouteParameters::RouteParameters()
     : zoom_level(18), print_instructions(false), alternate_route(true), geometry(true),
       compression(true), deprecatedAPI(false), uturn_default(false), classify(false),
-      matching_beta(-1.0), gps_precision(-1.0), check_sum(-1), num_results(1)
+      matching_beta(5), gps_precision(5), check_sum(-1), num_results(1)
 {
 }
 
@@ -131,3 +133,9 @@ void RouteParameters::addCoordinate(
         static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<0>(received_coordinates)),
         static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<1>(received_coordinates)));
 }
+
+void RouteParameters::getCoordinatesFromGeometry(const std::string &geometry_string)
+{
+    PolylineCompressor pc;
+    coordinates = pc.decode_string(geometry_string);
+}

data_structures/search_engine.hpp

@@ -33,6 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../routing_algorithms/many_to_many.hpp"
 #include "../routing_algorithms/map_matching.hpp"
 #include "../routing_algorithms/shortest_path.hpp"
+#include "../routing_algorithms/direct_shortest_path.hpp"
 
 #include <type_traits>
 
@@ -44,6 +45,7 @@ template <class DataFacadeT> class SearchEngine
 
   public:
     ShortestPathRouting<DataFacadeT> shortest_path;
+    DirectShortestPathRouting<DataFacadeT> direct_shortest_path;
     AlternativeRouting<DataFacadeT> alternative_path;
     ManyToManyRouting<DataFacadeT> distance_table;
     MapMatching<DataFacadeT> map_matching;
@@ -51,6 +53,7 @@ template <class DataFacadeT> class SearchEngine
     explicit SearchEngine(DataFacadeT *facade)
         : facade(facade),
           shortest_path(facade, engine_working_data),
+          direct_shortest_path(facade, engine_working_data),
           alternative_path(facade, engine_working_data),
           distance_table(facade, engine_working_data),
           map_matching(facade, engine_working_data)

data_structures/segment_information.hpp

@@ -34,6 +34,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../typedefs.h"
 
 #include <osrm/coordinate.hpp>
+#include <utility>
 
 // Struct fits everything in one cache line
 struct SegmentInformation
@@ -48,7 +49,7 @@ struct SegmentInformation
     bool necessary;
     bool is_via_location;
 
-    explicit SegmentInformation(const FixedPointCoordinate &location,
+    explicit SegmentInformation(FixedPointCoordinate location,
                                 const NodeID name_id,
                                 const EdgeWeight duration,
                                 const float length,
@@ -56,20 +57,20 @@ struct SegmentInformation
                                 const bool necessary,
                                 const bool is_via_location,
                                 const TravelMode travel_mode)
-        : location(location), name_id(name_id), duration(duration), length(length), bearing(0),
-          turn_instruction(turn_instruction), travel_mode(travel_mode), necessary(necessary),
-          is_via_location(is_via_location)
+        : location(std::move(location)), name_id(name_id), duration(duration), length(length),
+          bearing(0), turn_instruction(turn_instruction), travel_mode(travel_mode),
+          necessary(necessary), is_via_location(is_via_location)
     {
     }
 
-    explicit SegmentInformation(const FixedPointCoordinate &location,
+    explicit SegmentInformation(FixedPointCoordinate location,
                                 const NodeID name_id,
                                 const EdgeWeight duration,
                                 const float length,
                                 const TurnInstruction turn_instruction,
                                 const TravelMode travel_mode)
-        : location(location), name_id(name_id), duration(duration), length(length), bearing(0),
-          turn_instruction(turn_instruction), travel_mode(travel_mode),
+        : location(std::move(location)), name_id(name_id), duration(duration), length(length),
+          bearing(0), turn_instruction(turn_instruction), travel_mode(travel_mode),
           necessary(turn_instruction != TurnInstruction::NoTurn), is_via_location(false)
     {
     }

data_structures/shared_memory_factory.hpp

@@ -126,7 +126,7 @@ class SharedMemory
             shm = boost::interprocess::xsi_shared_memory(boost::interprocess::open_or_create, key,
                                                          size);
 #ifdef __linux__
-            if (-1 == shmctl(shm.get_shmid(), SHM_LOCK, 0))
+            if (-1 == shmctl(shm.get_shmid(), SHM_LOCK, nullptr))
             {
                 if (ENOMEM == errno)
                 {

data_structures/static_graph.hpp

@@ -87,8 +87,11 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
         return osrm::irange(BeginEdges(node), EndEdges(node));
     }
 
-    StaticGraph(const int nodes, std::vector<InputEdge> &graph)
+    template<typename ContainerT>
+    StaticGraph(const int nodes, const ContainerT &graph)
     {
+        BOOST_ASSERT(std::is_sorted(const_cast<ContainerT&>(graph).begin(), const_cast<ContainerT&>(graph).end()));
+
         number_of_nodes = nodes;
         number_of_edges = static_cast<EdgeIterator>(graph.size());
         node_array.resize(number_of_nodes + 1);

data_structures/static_rtree.hpp

@@ -316,8 +316,8 @@ class StaticRTree
     using IncrementalQueryNodeType = mapbox::util::variant<TreeNode, EdgeDataT>;
     struct IncrementalQueryCandidate
     {
-        explicit IncrementalQueryCandidate(const float dist, const IncrementalQueryNodeType &node)
-            : min_dist(dist), node(node)
+        explicit IncrementalQueryCandidate(const float dist, IncrementalQueryNodeType node)
+            : min_dist(dist), node(std::move(node))
         {
         }
 
@@ -344,9 +344,9 @@ class StaticRTree
     StaticRTree(const StaticRTree &) = delete;
 
     // Construct a packed Hilbert-R-Tree with Kamel-Faloutsos algorithm [1]
-    explicit StaticRTree(std::vector<EdgeDataT> &input_data_vector,
-                         const std::string tree_node_filename,
-                         const std::string leaf_node_filename,
+    explicit StaticRTree(const std::vector<EdgeDataT> &input_data_vector,
+                         const std::string &tree_node_filename,
+                         const std::string &leaf_node_filename,
                          const std::vector<QueryNode> &coordinate_list)
         : m_element_count(input_data_vector.size()), m_leaf_node_filename(leaf_node_filename)
     {
@@ -365,8 +365,8 @@ class StaticRTree
             [&input_data_vector, &input_wrapper_vector, &get_hilbert_number, &coordinate_list](
                 const tbb::blocked_range<uint64_t> &range)
             {
-                for (uint64_t element_counter = range.begin(); element_counter != range.end();
-                     ++element_counter)
+                for (uint64_t element_counter = range.begin(), end = range.end();
+                     element_counter != end; ++element_counter)
                 {
                     WrappedInputElement &current_wrapper = input_wrapper_vector[element_counter];
                     current_wrapper.m_array_index = element_counter;
@@ -476,7 +476,7 @@ class StaticRTree
         tbb::parallel_for(tbb::blocked_range<uint32_t>(0, search_tree_size),
                           [this, &search_tree_size](const tbb::blocked_range<uint32_t> &range)
                           {
-                              for (uint32_t i = range.begin(); i != range.end(); ++i)
+                              for (uint32_t i = range.begin(), end = range.end(); i != end; ++i)
                               {
                                   TreeNode &current_tree_node = this->m_search_tree[i];
                                   for (uint32_t j = 0; j < current_tree_node.child_count; ++j)
@@ -553,7 +553,7 @@ class StaticRTree
                          const boost::filesystem::path &leaf_file,
                          std::shared_ptr<CoordinateListT> coordinate_list)
         : m_search_tree(tree_node_ptr, number_of_nodes), m_leaf_node_filename(leaf_file.string()),
-          m_coordinate_list(coordinate_list)
+          m_coordinate_list(std::move(coordinate_list))
     {
         // open leaf node file and store thread specific pointer
         if (!boost::filesystem::exists(leaf_file))
@@ -646,22 +646,17 @@ class StaticRTree
         const FixedPointCoordinate &input_coordinate,
         std::vector<PhantomNode> &result_phantom_node_vector,
         const unsigned max_number_of_phantom_nodes,
+        const float max_distance = 1100,
         const unsigned max_checked_elements = 4 * LEAF_NODE_SIZE)
     {
         unsigned inspected_elements = 0;
         unsigned number_of_elements_from_big_cc = 0;
         unsigned number_of_elements_from_tiny_cc = 0;
 
-#ifdef NDEBUG
-        unsigned pruned_elements = 0;
-#endif
         std::pair<double, double> projected_coordinate = {
             mercator::lat2y(input_coordinate.lat / COORDINATE_PRECISION),
             input_coordinate.lon / COORDINATE_PRECISION};
 
-        // upper bound pruning technique
-        upper_bound<float> pruning_bound(max_number_of_phantom_nodes);
-
         // initialize queue with root element
         std::priority_queue<IncrementalQueryCandidate> traversal_queue;
         traversal_queue.emplace(0.f, m_search_tree[0]);
@@ -669,6 +664,11 @@ class StaticRTree
         while (!traversal_queue.empty())
         {
             const IncrementalQueryCandidate current_query_node = traversal_queue.top();
+            if (current_query_node.min_dist > max_distance &&
+                inspected_elements > max_checked_elements)
+            {
+                break;
+            }
             traversal_queue.pop();
 
             if (current_query_node.node.template is<TreeNode>())
@@ -692,18 +692,7 @@ class StaticRTree
                         // distance must be non-negative
                         BOOST_ASSERT(0.f <= current_perpendicular_distance);
 
-                        if (pruning_bound.get() >= current_perpendicular_distance ||
-                            current_edge.is_in_tiny_cc())
-                        {
-                            pruning_bound.insert(current_perpendicular_distance);
-                            traversal_queue.emplace(current_perpendicular_distance, current_edge);
-                        }
-#ifdef NDEBUG
-                        else
-                        {
-                            ++pruned_elements;
-                        }
-#endif
+                        traversal_queue.emplace(current_perpendicular_distance, current_edge);
                     }
                 }
                 else
@@ -771,9 +760,8 @@ class StaticRTree
             }
 
             // stop the search by flushing the queue
-            if ((result_phantom_node_vector.size() >= max_number_of_phantom_nodes &&
-                 number_of_elements_from_big_cc > 0) ||
-                inspected_elements >= max_checked_elements)
+            if (result_phantom_node_vector.size() >= max_number_of_phantom_nodes &&
+                number_of_elements_from_big_cc > 0)
             {
                 traversal_queue = std::priority_queue<IncrementalQueryCandidate>{};
             }
@@ -796,28 +784,18 @@ class StaticRTree
     // Returns elements within max_distance.
     // If the minium of elements could not be found in the search radius, widen
     // it until the minimum can be satisfied.
-    // At the number of returned nodes is capped at the given maximum.
     bool IncrementalFindPhantomNodeForCoordinateWithDistance(
         const FixedPointCoordinate &input_coordinate,
         std::vector<std::pair<PhantomNode, double>> &result_phantom_node_vector,
         const double max_distance,
-        const unsigned min_number_of_phantom_nodes,
-        const unsigned max_number_of_phantom_nodes,
         const unsigned max_checked_elements = 4 * LEAF_NODE_SIZE)
     {
         unsigned inspected_elements = 0;
-        unsigned number_of_elements_from_big_cc = 0;
-        unsigned number_of_elements_from_tiny_cc = 0;
-
-        unsigned pruned_elements = 0;
 
         std::pair<double, double> projected_coordinate = {
             mercator::lat2y(input_coordinate.lat / COORDINATE_PRECISION),
             input_coordinate.lon / COORDINATE_PRECISION};
 
-        // upper bound pruning technique
-        upper_bound<float> pruning_bound(max_number_of_phantom_nodes);
-
         // initialize queue with root element
         std::priority_queue<IncrementalQueryCandidate> traversal_queue;
         traversal_queue.emplace(0.f, m_search_tree[0]);
@@ -827,6 +805,12 @@ class StaticRTree
             const IncrementalQueryCandidate current_query_node = traversal_queue.top();
             traversal_queue.pop();
 
+            if (current_query_node.min_dist > max_distance ||
+                inspected_elements >= max_checked_elements)
+            {
+                break;
+            }
+
             if (current_query_node.node.template is<TreeNode>())
             { // current object is a tree node
                 const TreeNode &current_tree_node =
@@ -848,16 +832,10 @@ class StaticRTree
                         // distance must be non-negative
                         BOOST_ASSERT(0.f <= current_perpendicular_distance);
 
-                        if (pruning_bound.get() >= current_perpendicular_distance ||
-                            current_edge.is_in_tiny_cc())
+                        if (current_perpendicular_distance <= max_distance)
                         {
-                            pruning_bound.insert(current_perpendicular_distance);
                             traversal_queue.emplace(current_perpendicular_distance, current_edge);
                         }
-                        else
-                        {
-                            ++pruned_elements;
-                        }
                     }
                 }
                 else
@@ -873,7 +851,10 @@ class StaticRTree
                             child_rectangle.GetMinDist(input_coordinate);
                         BOOST_ASSERT(0.f <= lower_bound_to_element);
 
-                        traversal_queue.emplace(lower_bound_to_element, child_tree_node);
+                        if (lower_bound_to_element <= max_distance)
+                        {
+                            traversal_queue.emplace(lower_bound_to_element, child_tree_node);
+                        }
                     }
                 }
             }
@@ -884,14 +865,6 @@ class StaticRTree
                 const EdgeDataT &current_segment =
                     current_query_node.node.template get<EdgeDataT>();
 
-                // continue searching for the first segment from a big component
-                if (number_of_elements_from_big_cc == 0 &&
-                    number_of_elements_from_tiny_cc >= max_number_of_phantom_nodes - 1 &&
-                    current_segment.is_in_tiny_cc())
-                {
-                    continue;
-                }
-
                 // check if it is smaller than what we had before
                 float current_ratio = 0.f;
                 FixedPointCoordinate foot_point_coordinate_on_segment;
@@ -902,9 +875,7 @@ class StaticRTree
                         m_coordinate_list->at(current_segment.v), input_coordinate,
                         projected_coordinate, foot_point_coordinate_on_segment, current_ratio);
 
-                if (number_of_elements_from_big_cc > 0 &&
-                    result_phantom_node_vector.size() >= min_number_of_phantom_nodes &&
-                    current_perpendicular_distance >= max_distance)
+                if (current_perpendicular_distance >= max_distance)
                 {
                     traversal_queue = std::priority_queue<IncrementalQueryCandidate>{};
                     continue;
@@ -928,36 +899,14 @@ class StaticRTree
                 // set forward and reverse weights on the phantom node
                 SetForwardAndReverseWeightsOnPhantomNode(current_segment,
                                                          result_phantom_node_vector.back().first);
-
-                // update counts on what we found from which result class
-                if (current_segment.is_in_tiny_cc())
-                { // found an element in tiny component
-                    ++number_of_elements_from_tiny_cc;
-                }
-                else
-                { // found an element in a big component
-                    ++number_of_elements_from_big_cc;
-                }
             }
 
             // stop the search by flushing the queue
-            if ((result_phantom_node_vector.size() >= max_number_of_phantom_nodes &&
-                 number_of_elements_from_big_cc > 0) ||
-                inspected_elements >= max_checked_elements)
+            if (inspected_elements >= max_checked_elements)
             {
                 traversal_queue = std::priority_queue<IncrementalQueryCandidate>{};
             }
         }
-        // SimpleLogger().Write() << "result_phantom_node_vector.size(): " <<
-        // result_phantom_node_vector.size();
-        // SimpleLogger().Write() << "max_number_of_phantom_nodes: " << max_number_of_phantom_nodes;
-        // SimpleLogger().Write() << "number_of_elements_from_big_cc: " <<
-        // number_of_elements_from_big_cc;
-        // SimpleLogger().Write() << "number_of_elements_from_tiny_cc: " <<
-        // number_of_elements_from_tiny_cc;
-        // SimpleLogger().Write() << "inspected_elements: " << inspected_elements;
-        // SimpleLogger().Write() << "max_checked_elements: " << max_checked_elements;
-        // SimpleLogger().Write() << "pruned_elements: " << pruned_elements;
 
         return !result_phantom_node_vector.empty();
     }

datastore.cpp

@@ -164,6 +164,10 @@ int main(const int argc, const char *argv[])
         {
             throw osrm::exception("no geometry file found");
         }
+        if (server_paths.find("core") == server_paths.end())
+        {
+            throw osrm::exception("no core file found");
+        }
 
         ServerPaths::const_iterator paths_iterator = server_paths.find("hsgrdata");
         BOOST_ASSERT(server_paths.end() != paths_iterator);
@@ -199,6 +203,10 @@ int main(const int argc, const char *argv[])
         BOOST_ASSERT(server_paths.end() != paths_iterator);
         BOOST_ASSERT(!paths_iterator->second.empty());
         const boost::filesystem::path &geometries_data_path = paths_iterator->second;
+        paths_iterator = server_paths.find("core");
+        BOOST_ASSERT(server_paths.end() != paths_iterator);
+        BOOST_ASSERT(!paths_iterator->second.empty());
+        const boost::filesystem::path &core_marker_path = paths_iterator->second;
 
         // determine segment to use
         bool segment2_in_use = SharedMemory::RegionExists(LAYOUT_2);
@@ -222,8 +230,7 @@ int main(const int argc, const char *argv[])
         // Allocate a memory layout in shared memory, deallocate previous
         SharedMemory *layout_memory =
             SharedMemoryFactory::Get(layout_region, sizeof(SharedDataLayout));
-        SharedDataLayout *shared_layout_ptr = static_cast<SharedDataLayout *>(layout_memory->Ptr());
-        shared_layout_ptr = new (layout_memory->Ptr()) SharedDataLayout();
+        SharedDataLayout *shared_layout_ptr = new (layout_memory->Ptr()) SharedDataLayout();
 
         shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::FILE_INDEX_PATH,
                                               file_index_path.length() + 1);
@@ -264,9 +271,10 @@ int main(const int argc, const char *argv[])
 
         boost::filesystem::ifstream hsgr_input_stream(hsgr_path, std::ios::binary);
 
-        FingerPrint fingerprint_loaded, fingerprint_orig;
+        FingerPrint fingerprint_valid = FingerPrint::GetValid();
+        FingerPrint fingerprint_loaded;
         hsgr_input_stream.read((char *)&fingerprint_loaded, sizeof(FingerPrint));
-        if (fingerprint_loaded.TestGraphUtil(fingerprint_orig))
+        if (fingerprint_loaded.TestGraphUtil(fingerprint_valid))
         {
             SimpleLogger().Write(logDEBUG) << "Fingerprint checked out ok";
         }
@@ -328,6 +336,13 @@ int main(const int argc, const char *argv[])
         }
         shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::TIMESTAMP, m_timestamp.length());
 
+        // load core marker size
+        boost::filesystem::ifstream core_marker_file(core_marker_path, std::ios::binary);
+
+        uint32_t number_of_core_markers = 0;
+        core_marker_file.read((char *)&number_of_core_markers, sizeof(uint32_t));
+        shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::CORE_MARKER, number_of_core_markers);
+
         // load coordinate size
         boost::filesystem::ifstream nodes_input_stream(nodes_data_path, std::ios::binary);
         unsigned coordinate_list_size = 0;
@@ -508,6 +523,35 @@ int main(const int argc, const char *argv[])
         }
         tree_node_file.close();
 
+        // load core markers
+        std::vector<char> unpacked_core_markers(number_of_core_markers);
+        core_marker_file.read((char *)unpacked_core_markers.data(), sizeof(char)*number_of_core_markers);
+
+        unsigned *core_marker_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+            shared_memory_ptr, SharedDataLayout::CORE_MARKER);
+
+        for (auto i = 0u; i < number_of_core_markers; ++i)
+        {
+            BOOST_ASSERT(unpacked_core_markers[i] == 0 || unpacked_core_markers[i] == 1);
+
+            if (unpacked_core_markers[i] == 1)
+            {
+                const unsigned bucket = i / 32;
+                const unsigned offset = i % 32;
+                const unsigned value = [&]
+                {
+                    unsigned return_value = 0;
+                    if (0 != offset)
+                    {
+                        return_value = core_marker_ptr[bucket];
+                    }
+                    return return_value;
+                }();
+
+                core_marker_ptr[bucket] = (value | (1 << offset));
+            }
+        }
+
         // load the nodes of the search graph
         QueryGraph::NodeArrayEntry *graph_node_list_ptr =
             shared_layout_ptr->GetBlockPtr<QueryGraph::NodeArrayEntry, true>(

descriptors/description_factory.cpp

@@ -28,7 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "description_factory.hpp"
 
 #include "../algorithms/polyline_formatter.hpp"
-#include "../data_structures/coordinate_calculation.hpp"
+#include "../algorithms/coordinate_calculation.hpp"
 #include "../data_structures/internal_route_result.hpp"
 #include "../data_structures/turn_instructions.hpp"
 #include "../util/container.hpp"
@@ -173,6 +173,7 @@ void DescriptionFactory::Run(const unsigned zoom_level)
     //        }
     //        string0 = string1;
     //    }
+    //
 
     float segment_length = 0.;
     EdgeWeight segment_duration = 0;
@@ -197,7 +198,8 @@ void DescriptionFactory::Run(const unsigned zoom_level)
 
     // Post-processing to remove empty or nearly empty path segments
     if (path_description.size() > 2 &&
-        std::numeric_limits<float>::epsilon() > path_description.back().length)
+        std::numeric_limits<float>::epsilon() > path_description.back().length &&
+        !(path_description.end() - 2)->is_via_location)
     {
         path_description.pop_back();
         path_description.back().necessary = true;
@@ -206,7 +208,8 @@ void DescriptionFactory::Run(const unsigned zoom_level)
     }
 
     if (path_description.size() > 2 &&
-        std::numeric_limits<float>::epsilon() > path_description.front().length)
+        std::numeric_limits<float>::epsilon() > path_description.front().length &&
+        !(path_description.begin() + 1)->is_via_location)
     {
         path_description.erase(path_description.begin());
         path_description.front().turn_instruction = TurnInstruction::HeadOn;

descriptors/descriptor_base.hpp

@@ -28,7 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef DESCRIPTOR_BASE_HPP
 #define DESCRIPTOR_BASE_HPP
 
-#include "../data_structures/coordinate_calculation.hpp"
+#include "../algorithms/coordinate_calculation.hpp"
 #include "../data_structures/internal_route_result.hpp"
 #include "../data_structures/phantom_node.hpp"
 #include "../typedefs.h"

descriptors/json_descriptor.hpp

@@ -52,15 +52,8 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
     DescriptorConfig config;
     DescriptionFactory description_factory, alternate_description_factory;
     FixedPointCoordinate current;
-    unsigned entered_restricted_area_count;
-    struct RoundAbout
-    {
-        RoundAbout() : start_index(INT_MAX), name_id(INVALID_NAMEID), leave_at_exit(INT_MAX) {}
-        int start_index;
-        unsigned name_id;
-        int leave_at_exit;
-    } round_about;
 
+  public:
     struct Segment
     {
         Segment() : name_id(INVALID_NAMEID), length(-1), position(0) {}
@@ -69,11 +62,12 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
         int length;
         unsigned position;
     };
+  private:
     std::vector<Segment> shortest_path_segments, alternative_path_segments;
     ExtractRouteNames<DataFacadeT, Segment> GenerateRouteNames;
 
   public:
-    explicit JSONDescriptor(DataFacadeT *facade) : facade(facade), entered_restricted_area_count(0)
+    explicit JSONDescriptor(DataFacadeT *facade) : facade(facade)
     {
     }
 
@@ -143,9 +137,7 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
         }
         if (config.instructions)
         {
-            osrm::json::Array json_route_instructions;
-            BuildTextualDescription(description_factory, json_route_instructions,
-                                    raw_route.shortest_path_length, shortest_path_segments);
+            osrm::json::Array json_route_instructions = BuildTextualDescription(description_factory, shortest_path_segments);
             json_result.values["route_instructions"] = json_route_instructions;
         }
         description_factory.BuildRouteSummary(description_factory.get_entire_length(),
@@ -222,9 +214,7 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
             osrm::json::Array json_current_alt_instructions;
             if (config.instructions)
             {
-                BuildTextualDescription(
-                    alternate_description_factory, json_current_alt_instructions,
-                    raw_route.alternative_path_length, alternative_path_segments);
+                json_alt_instructions = BuildTextualDescription(alternate_description_factory, alternative_path_segments);
                 json_alt_instructions.values.push_back(json_current_alt_instructions);
                 json_result.values["alternative_instructions"] = json_alt_instructions;
             }
@@ -276,6 +266,11 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
             json_result.values["alternative_names"] = json_alternate_names_array;
         }
 
+        json_result.values["hint_data"] = BuildHintData(raw_route);
+    }
+
+    inline osrm::json::Object BuildHintData(const InternalRouteResult& raw_route) const
+    {
         osrm::json::Object json_hint_object;
         json_hint_object.values["checksum"] = facade->GetCheckSum();
         osrm::json::Array json_location_hint_array;
@@ -290,24 +285,27 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
                                       hint);
         json_location_hint_array.values.push_back(hint);
         json_hint_object.values["locations"] = json_location_hint_array;
-        json_result.values["hint_data"] = json_hint_object;
 
-        // render the content to the output array
-        // TIMER_START(route_render);
-        // osrm::json::render(reply.content, json_result);
-        // TIMER_STOP(route_render);
-        // SimpleLogger().Write(logDEBUG) << "rendering took: " << TIMER_MSEC(route_render);
+        return json_hint_object;
     }
 
-    // TODO: reorder parameters
-    inline void BuildTextualDescription(DescriptionFactory &description_factory,
-                                        osrm::json::Array &json_instruction_array,
-                                        const int route_length,
-                                        std::vector<Segment> &route_segments_list)
+    inline osrm::json::Array BuildTextualDescription(const DescriptionFactory &description_factory,
+                                                     std::vector<Segment> &route_segments_list) const
     {
+        osrm::json::Array json_instruction_array;
+
         // Segment information has following format:
         //["instruction id","streetname",length,position,time,"length","earth_direction",azimuth]
         unsigned necessary_segments_running_index = 0;
+
+        struct RoundAbout
+        {
+            RoundAbout() : start_index(INT_MAX), name_id(INVALID_NAMEID), leave_at_exit(INT_MAX) {}
+            int start_index;
+            unsigned name_id;
+            int leave_at_exit;
+        } round_about;
+
         round_about.leave_at_exit = 0;
         round_about.name_id = 0;
         std::string temp_dist, temp_length, temp_duration, temp_bearing, temp_instruction;
@@ -317,7 +315,6 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
         {
             osrm::json::Array json_instruction_row;
             TurnInstruction current_instruction = segment.turn_instruction;
-            entered_restricted_area_count += (current_instruction != segment.turn_instruction);
             if (TurnInstructionsClass::TurnIsNecessary(current_instruction))
             {
                 if (TurnInstruction::EnterRoundAbout == current_instruction)
@@ -386,6 +383,8 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
         json_last_instruction_row.values.push_back(bearing::get(0.0));
         json_last_instruction_row.values.push_back(0.);
         json_instruction_array.values.push_back(json_last_instruction_row);
+
+        return json_instruction_array;
     }
 };
 

docker/Dockerfile

@@ -0,0 +1,21 @@
+FROM ubuntu:14.04
+
+RUN apt-get update -y
+RUN apt-get install -y build-essential git-core python-pip python-software-properties software-properties-common
+
+RUN apt-get -y install gcc-4.8 g++-4.8 libboost1.55-all-dev llvm-3.4
+RUN apt-get -y install libbz2-dev libstxxl-dev libstxxl1 libxml2-dev
+RUN apt-get -y install libzip-dev lua5.1 liblua5.1-0-dev libtbb-dev libgdal-dev ruby1.9
+RUN apt-get -y install curl cmake cmake-curses-gui
+
+RUN pip install awscli
+
+# luabind
+RUN curl https://gist.githubusercontent.com/DennisOSRM/f2eb7b948e6fe1ae319e/raw/install-luabind.sh | sudo bash
+# osmosis
+RUN curl -s https://gist.githubusercontent.com/DennisOSRM/803a64a9178ec375069f/raw/ | sudo bash
+
+RUN useradd -ms /bin/bash mapbox
+USER mapbox
+ENV HOME /home/mapbox
+WORKDIR /home/mapbox

docker/README

@@ -0,0 +1,6 @@
+# Docker based continious integration
+
+Run ```./docker/build-image.sh``` to build a docker image.
+The image contains all the build dependencies and the state of the local git repository.
+
+Run ```./docker/run-gcc.sh``` to build OSRM with g++ and run all tests.

docker/build-image.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+set -e
+set -o pipefail
+
+docker build \
+    -t mapbox/osrm:linux \
+    docker/
+

docker/run-clang.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -e
+set -o pipefail
+
+docker run \
+    -i \
+    -e "CXX=clang++" \
+    -v `pwd`:/home/mapbox/osrm-backend \
+    -t mapbox/osrm:linux \
+    osrm-backend/docker/test.sh

docker/run-gcc.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -e
+set -o pipefail
+
+docker run \
+    -i \
+    -e "CXX=g++" \
+    -v `pwd`:/home/mapbox/osrm-backend \
+    -t mapbox/osrm:linux \
+    osrm-backend/docker/test.sh

docker/test.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+set -e
+set -o pipefail
+
+export CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Release"
+export PATH=$PATH:/home/mapbox/.gem/ruby/1.9.1/bin:/home/mapbox/osrm-backend/vendor/bundle/ruby/1.9.1/bin
+
+cd /home/mapbox/osrm-backend
+gem install --user-install bundler
+bundle install --path vendor/bundle
+[ -d build ] && rm -rf build
+mkdir -p build
+cd build
+cmake .. $CMAKEOPTIONS -DBUILD_TOOLS=1
+
+make -j`nproc`
+make tests -j`nproc`
+./datastructure-tests
+./algorithm-tests
+cd ..
+bundle exec cucumber -p verify

extract.cpp

@@ -73,7 +73,7 @@ int main(int argc, char *argv[])
                                              << " not found!";
             return 1;
         }
-        return extractor().run(extractor_config);
+        return extractor(extractor_config).run();
     }
     catch (const std::exception &e)
     {

extractor/extraction_containers.hpp

@@ -30,15 +30,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "internal_extractor_edge.hpp"
 #include "first_and_last_segment_of_way.hpp"
+#include "scripting_environment.hpp"
 #include "../data_structures/external_memory_node.hpp"
 #include "../data_structures/restriction.hpp"
-#include "../util/fingerprint.hpp"
 
 #include <stxxl/vector>
+#include <unordered_map>
 
 /**
  * Uses external memory containers from stxxl to store all the data that
  * is collected by the extractor callbacks.
+ *
+ * The data is the filtered, aggregated and finally written to disk.
  */
 class ExtractionContainers
 {
@@ -49,6 +52,14 @@ class ExtractionContainers
 #else
     const static unsigned stxxl_memory = ((sizeof(std::size_t) == 4) ? INT_MAX : UINT_MAX);
 #endif
+    void PrepareNodes();
+    void PrepareRestrictions();
+    void PrepareEdges(lua_State *segment_state);
+
+    void WriteNodes(std::ofstream& file_out_stream) const;
+    void WriteRestrictions(const std::string& restrictions_file_name) const;
+    void WriteEdges(std::ofstream& file_out_stream) const;
+    void WriteNames(const std::string& names_file_name) const;
   public:
     using STXXLNodeIDVector = stxxl::vector<NodeID>;
     using STXXLNodeVector = stxxl::vector<ExternalMemoryNode>;
@@ -63,14 +74,17 @@ class ExtractionContainers
     STXXLStringVector name_list;
     STXXLRestrictionsVector restrictions_list;
     STXXLWayIDStartEndVector way_start_end_id_list;
-    const FingerPrint fingerprint;
+    std::unordered_map<NodeID, NodeID> external_to_internal_node_id_map;
+    unsigned max_internal_node_id;
 
     ExtractionContainers();
 
     ~ExtractionContainers();
 
     void PrepareData(const std::string &output_file_name,
-                     const std::string &restrictions_file_name);
+                     const std::string &restrictions_file_name,
+                     const std::string &names_file_name,
+                     lua_State *segment_state);
 };
 
 #endif /* EXTRACTION_CONTAINERS_HPP */

extractor/extraction_helper_functions.hpp

@@ -102,7 +102,7 @@ unsigned parseDuration(const std::string &s)
                 minutes = cast::string_to_int(result[1]);
                 hours = cast::string_to_int(result[0]);
             }
-            return 10 * (3600 * hours + 60 * minutes + seconds);
+            return (3600 * hours + 60 * minutes + seconds);
         }
     }
     else if (iso_8601_duration_is_valid(s))

extractor/extraction_way.hpp

@@ -51,7 +51,6 @@ struct ExtractionWay
         duration = -1;
         roundabout = false;
         is_access_restricted = false;
-        ignore_in_grid = false;
         name.clear();
         forward_travel_mode = TRAVEL_MODE_DEFAULT;
         backward_travel_mode = TRAVEL_MODE_DEFAULT;
@@ -121,7 +120,6 @@ struct ExtractionWay
     std::string name;
     bool roundabout;
     bool is_access_restricted;
-    bool ignore_in_grid;
     TravelMode forward_travel_mode : 4;
     TravelMode backward_travel_mode : 4;
 };

extractor/extractor.cpp

@@ -34,10 +34,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "restriction_parser.hpp"
 #include "scripting_environment.hpp"
 
+#include "../data_structures/raster_source.hpp"
 #include "../util/git_sha.hpp"
 #include "../util/make_unique.hpp"
 #include "../util/simple_logger.hpp"
 #include "../util/timing_util.hpp"
+#include "../util/lua_util.hpp"
 
 #include "../typedefs.h"
 
@@ -82,7 +84,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  .restrictions : Turn restrictions that are used my osrm-prepare to construct the edge-expanded graph
  *
  */
-int extractor::run(const ExtractorConfig &extractor_config)
+int extractor::run()
 {
     try
     {
@@ -91,20 +93,20 @@ int extractor::run(const ExtractorConfig &extractor_config)
 
         const unsigned recommended_num_threads = tbb::task_scheduler_init::default_num_threads();
         const auto number_of_threads =
-            std::min(recommended_num_threads, extractor_config.requested_num_threads);
+            std::min(recommended_num_threads, config.requested_num_threads);
         tbb::task_scheduler_init init(number_of_threads);
 
-        SimpleLogger().Write() << "Input file: " << extractor_config.input_path.filename().string();
-        SimpleLogger().Write() << "Profile: " << extractor_config.profile_path.filename().string();
+        SimpleLogger().Write() << "Input file: " << config.input_path.filename().string();
+        SimpleLogger().Write() << "Profile: " << config.profile_path.filename().string();
         SimpleLogger().Write() << "Threads: " << number_of_threads;
 
         // setup scripting environment
-        ScriptingEnvironment scripting_environment(extractor_config.profile_path.string().c_str());
+        ScriptingEnvironment scripting_environment(config.profile_path.string().c_str());
 
         ExtractionContainers extraction_containers;
         auto extractor_callbacks = osrm::make_unique<ExtractorCallbacks>(extraction_containers);
 
-        const osmium::io::File input_file(extractor_config.input_path.string());
+        const osmium::io::File input_file(config.input_path.string());
         osmium::io::Reader reader(input_file);
         const osmium::io::Header header = reader.header();
 
@@ -116,6 +118,17 @@ int extractor::run(const ExtractorConfig &extractor_config)
         SimpleLogger().Write() << "Parsing in progress..";
         TIMER_START(parsing);
 
+        lua_State *segment_state = scripting_environment.get_lua_state();
+
+        if (lua_function_exists(segment_state, "source_function"))
+        {
+            // bind a single instance of SourceContainer class to relevant lua state
+            SourceContainer sources;
+            luabind::globals(segment_state)["sources"] = sources;
+
+            luabind::call_function<void>(segment_state, "source_function");
+        }
+
         std::string generator = header.get("generator");
         if (generator.empty())
         {
@@ -131,7 +144,7 @@ int extractor::run(const ExtractorConfig &extractor_config)
         }
         SimpleLogger().Write() << "timestamp: " << timestamp;
 
-        boost::filesystem::ofstream timestamp_out(extractor_config.timestamp_file_name);
+        boost::filesystem::ofstream timestamp_out(config.timestamp_file_name);
         timestamp_out.write(timestamp.c_str(), timestamp.length());
         timestamp_out.close();
 
@@ -148,7 +161,7 @@ int extractor::run(const ExtractorConfig &extractor_config)
         {
             // create a vector of iterators into the buffer
             std::vector<osmium::memory::Buffer::const_iterator> osm_elements;
-            for (auto iter = std::begin(buffer); iter != std::end(buffer); ++iter)
+            for (auto iter = std::begin(buffer), end = std::end(buffer); iter != end; ++iter)
             {
                 osm_elements.push_back(iter);
             }
@@ -167,7 +180,7 @@ int extractor::run(const ExtractorConfig &extractor_config)
                     ExtractionWay result_way;
                     lua_State *local_state = scripting_environment.get_lua_state();
 
-                    for (auto x = range.begin(); x != range.end(); ++x)
+                    for (auto x = range.begin(), end = range.end(); x != end; ++x)
                     {
                         const auto entity = osm_elements[x];
 
@@ -236,12 +249,15 @@ int extractor::run(const ExtractorConfig &extractor_config)
             return 1;
         }
 
-        extraction_containers.PrepareData(extractor_config.output_file_name,
-                                          extractor_config.restriction_file_name);
+        extraction_containers.PrepareData(config.output_file_name,
+                                          config.restriction_file_name,
+                                          config.names_file_name,
+                                          segment_state);
+
         TIMER_STOP(extracting);
         SimpleLogger().Write() << "extraction finished after " << TIMER_SEC(extracting) << "s";
         SimpleLogger().Write() << "To prepare the data for routing, run: "
-                               << "./osrm-prepare " << extractor_config.output_file_name
+                               << "./osrm-prepare " << config.output_file_name
                                << std::endl;
     }
     catch (std::exception &e)

extractor/extractor.hpp

@@ -30,8 +30,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "extractor_options.hpp"
 
-struct extractor
+class extractor
 {
-    int run(const ExtractorConfig &extractor_config);
+public:
+  extractor(ExtractorConfig extractor_config) : config(std::move(extractor_config)) {}
+    int run();
+private:
+   ExtractorConfig config;
 };
 #endif /* EXTRACTOR_HPP */

extractor/extractor_callbacks.cpp

@@ -108,17 +108,40 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                                        << " of size " << input_way.nodes().size();
         return;
     }
+
+    InternalExtractorEdge::WeightData forward_weight_data;
+    InternalExtractorEdge::WeightData backward_weight_data;
+
     if (0 < parsed_way.duration)
     {
-        // TODO: iterate all way segments and set duration corresponding to the length of each
-        // segment
-        const_cast<ExtractionWay &>(parsed_way).forward_speed =
-            parsed_way.duration / (input_way.nodes().size() - 1);
-        const_cast<ExtractionWay &>(parsed_way).backward_speed =
-            parsed_way.duration / (input_way.nodes().size() - 1);
+        const unsigned num_edges = (input_way.nodes().size() - 1);
+        // FIXME We devide by the numer of nodes here, but should rather consider
+        // the length of each segment. We would eigther have to compute the length
+        // of the whole way here (we can't: no node coordinates) or push that back
+        // to the container and keep a reference to the way.
+        forward_weight_data.duration = parsed_way.duration / num_edges;
+        forward_weight_data.type = InternalExtractorEdge::WeightType::WAY_DURATION;
+        backward_weight_data.duration = parsed_way.duration / num_edges;
+        backward_weight_data.type = InternalExtractorEdge::WeightType::WAY_DURATION;
+    }
+    else
+    {
+        if (parsed_way.forward_speed > 0 &&
+            parsed_way.forward_travel_mode != TRAVEL_MODE_INACCESSIBLE)
+        {
+            forward_weight_data.speed = parsed_way.forward_speed;
+            forward_weight_data.type = InternalExtractorEdge::WeightType::SPEED;
+        }
+        if (parsed_way.backward_speed > 0 &&
+            parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE)
+        {
+            backward_weight_data.speed = parsed_way.backward_speed;
+            backward_weight_data.type = InternalExtractorEdge::WeightType::SPEED;
+        }
     }
 
-    if (std::numeric_limits<double>::epsilon() >= std::abs(-1. - parsed_way.forward_speed))
+    if (forward_weight_data.type == InternalExtractorEdge::WeightType::INVALID
+     && backward_weight_data.type == InternalExtractorEdge::WeightType::INVALID)
     {
         SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << input_way.id();
         return;
@@ -144,81 +167,68 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                             ((parsed_way.forward_speed != parsed_way.backward_speed) ||
                              (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode));
 
-    auto pair_wise_segment_split =
-        [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
-    {
-        // SimpleLogger().Write() << "adding edge (" << first_node.ref() << "," <<
-        // last_node.ref() << "), fwd speed: " << parsed_way.forward_speed;
-        external_memory.all_edges_list.push_back(InternalExtractorEdge(
-            first_node.ref(), last_node.ref(),
-            ((split_edge || TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode)
-                 ? ExtractionWay::oneway
-                 : ExtractionWay::bidirectional),
-            parsed_way.forward_speed, name_id, parsed_way.roundabout, parsed_way.ignore_in_grid,
-            (0 < parsed_way.duration), parsed_way.is_access_restricted,
-            parsed_way.forward_travel_mode, split_edge));
-        external_memory.used_node_id_list.push_back(first_node.ref());
-    };
+    std::transform(input_way.nodes().begin(), input_way.nodes().end(),
+                   std::back_inserter(external_memory.used_node_id_list),
+                   [](const osmium::NodeRef& ref) { return ref.ref(); });
 
     const bool is_opposite_way = TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode;
+
+    // traverse way in reverse in this case
     if (is_opposite_way)
     {
-        const_cast<ExtractionWay &>(parsed_way).forward_travel_mode =
-            parsed_way.backward_travel_mode;
-        const_cast<ExtractionWay &>(parsed_way).backward_travel_mode = TRAVEL_MODE_INACCESSIBLE;
+        BOOST_ASSERT(split_edge == false);
+        BOOST_ASSERT(parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);
         osrm::for_each_pair(input_way.nodes().crbegin(), input_way.nodes().crend(),
-                            pair_wise_segment_split);
-        external_memory.used_node_id_list.push_back(input_way.nodes().front().ref());
+                            [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
+                            {
+                                external_memory.all_edges_list.push_back(InternalExtractorEdge(
+                                    first_node.ref(), last_node.ref(), name_id, backward_weight_data,
+                                    true, false, parsed_way.roundabout, parsed_way.is_access_restricted,
+                                    parsed_way.backward_travel_mode, false));
+                            });
+
+        external_memory.way_start_end_id_list.push_back(
+            {
+                static_cast<EdgeID>(input_way.id()),
+                static_cast<NodeID>(input_way.nodes().back().ref()),
+                static_cast<NodeID>(input_way.nodes()[input_way.nodes().size() - 2].ref()),
+                static_cast<NodeID>(input_way.nodes()[1].ref()),
+                static_cast<NodeID>(input_way.nodes()[0].ref())
+             }
+        );
     }
     else
     {
+        const bool forward_only = split_edge || TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode;
         osrm::for_each_pair(input_way.nodes().cbegin(), input_way.nodes().cend(),
-                            pair_wise_segment_split);
-        external_memory.used_node_id_list.push_back(input_way.nodes().back().ref());
-    }
-
-    // The following information is needed to identify start and end segments of restrictions
-    external_memory.way_start_end_id_list.push_back(
-        {(EdgeID)input_way.id(),
-         (NodeID)input_way.nodes()[0].ref(),
-         (NodeID)input_way.nodes()[1].ref(),
-         (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref(),
-         (NodeID)input_way.nodes().back().ref()});
-
-    if (split_edge)
-    { // Only true if the way should be split
-        BOOST_ASSERT(parsed_way.backward_travel_mode > 0);
-        auto pair_wise_segment_split_2 =
-            [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
-        {
-            // SimpleLogger().Write() << "adding edge (" << last_node.ref() << "," <<
-            // first_node.ref() << "), bwd speed: " << parsed_way.backward_speed;
-            external_memory.all_edges_list.push_back(InternalExtractorEdge(
-                last_node.ref(), first_node.ref(), ExtractionWay::oneway, parsed_way.backward_speed,
-                name_id, parsed_way.roundabout, parsed_way.ignore_in_grid,
-                (0 < parsed_way.duration), parsed_way.is_access_restricted,
-                parsed_way.backward_travel_mode, split_edge));
-        };
-
-        if (is_opposite_way)
-        {
-            // SimpleLogger().Write() << "opposite2";
-            osrm::for_each_pair(input_way.nodes().crbegin(), input_way.nodes().crend(),
-                                pair_wise_segment_split_2);
-            external_memory.used_node_id_list.push_back(input_way.nodes().front().ref());
-        }
-        else
+                            [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
+                            {
+                                external_memory.all_edges_list.push_back(InternalExtractorEdge(
+                                    first_node.ref(), last_node.ref(), name_id, forward_weight_data,
+                                    true, !forward_only, parsed_way.roundabout, parsed_way.is_access_restricted,
+                                    parsed_way.forward_travel_mode, split_edge));
+                            });
+        if (split_edge)
         {
+            BOOST_ASSERT(parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);
             osrm::for_each_pair(input_way.nodes().cbegin(), input_way.nodes().cend(),
-                                pair_wise_segment_split_2);
-            external_memory.used_node_id_list.push_back(input_way.nodes().back().ref());
+                                [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
+                                {
+                                    external_memory.all_edges_list.push_back(InternalExtractorEdge(
+                                        first_node.ref(), last_node.ref(), name_id, backward_weight_data,
+                                        false, true, parsed_way.roundabout, parsed_way.is_access_restricted,
+                                        parsed_way.backward_travel_mode, true));
+                                });
         }
 
         external_memory.way_start_end_id_list.push_back(
-            {(EdgeID)input_way.id(),
-             (NodeID)input_way.nodes()[1].ref(),
-             (NodeID)input_way.nodes()[0].ref(),
-             (NodeID)input_way.nodes().back().ref(),
-             (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref()});
+            {
+                static_cast<EdgeID>(input_way.id()),
+                static_cast<NodeID>(input_way.nodes().back().ref()),
+                static_cast<NodeID>(input_way.nodes()[input_way.nodes().size() - 2].ref()),
+                static_cast<NodeID>(input_way.nodes()[1].ref()),
+                static_cast<NodeID>(input_way.nodes()[0].ref())
+             }
+        );
     }
 }

extractor/extractor_options.cpp

@@ -135,6 +135,7 @@ void ExtractorOptions::GenerateOutputFilesNames(ExtractorConfig &extractor_confi
     boost::filesystem::path &input_path = extractor_config.input_path;
     extractor_config.output_file_name = input_path.string();
     extractor_config.restriction_file_name = input_path.string();
+    extractor_config.names_file_name = input_path.string();
     extractor_config.timestamp_file_name = input_path.string();
     std::string::size_type pos = extractor_config.output_file_name.find(".osm.bz2");
     if (pos == std::string::npos)
@@ -156,12 +157,14 @@ void ExtractorOptions::GenerateOutputFilesNames(ExtractorConfig &extractor_confi
         {
             extractor_config.output_file_name.append(".osrm");
             extractor_config.restriction_file_name.append(".osrm.restrictions");
+            extractor_config.names_file_name.append(".osrm.names");
             extractor_config.timestamp_file_name.append(".osrm.timestamp");
         }
         else
         {
             extractor_config.output_file_name.replace(pos, 5, ".osrm");
             extractor_config.restriction_file_name.replace(pos, 5, ".osrm.restrictions");
+            extractor_config.names_file_name.replace(pos, 5, ".osrm.names");
             extractor_config.timestamp_file_name.replace(pos, 5, ".osrm.timestamp");
         }
     }
@@ -169,6 +172,7 @@ void ExtractorOptions::GenerateOutputFilesNames(ExtractorConfig &extractor_confi
     {
         extractor_config.output_file_name.replace(pos, 8, ".osrm");
         extractor_config.restriction_file_name.replace(pos, 8, ".osrm.restrictions");
+        extractor_config.names_file_name.replace(pos, 8, ".osrm.names");
         extractor_config.timestamp_file_name.replace(pos, 8, ".osrm.timestamp");
     }
 }

extractor/extractor_options.hpp

@@ -48,6 +48,7 @@ struct ExtractorConfig
 
     std::string output_file_name;
     std::string restriction_file_name;
+    std::string names_file_name;
     std::string timestamp_file_name;
 
     unsigned requested_num_threads;

extractor/internal_extractor_edge.hpp

@@ -30,90 +30,124 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "../typedefs.h"
 #include "../data_structures/travel_mode.hpp"
+#include "../data_structures/import_edge.hpp"
 
 #include <boost/assert.hpp>
 
 #include <osrm/coordinate.hpp>
+#include <utility>
 
 struct InternalExtractorEdge
 {
-    InternalExtractorEdge()
-        : start(0), target(0), speed(0), name_id(0), direction(0), is_roundabout(false),
-          is_in_tiny_cc(false), is_duration_set(false), is_access_restricted(false),
-          is_split(false), travel_mode(TRAVEL_MODE_INACCESSIBLE)
+    // specify the type of the weight data
+    enum class WeightType : char {
+        INVALID,
+        SPEED,
+        EDGE_DURATION,
+        WAY_DURATION,
+    };
+
+    struct WeightData
+    {
+
+        WeightData() : duration(0.0), type(WeightType::INVALID)
+        {
+        }
+
+        union
+        {
+            double duration;
+            double speed;
+        };
+        WeightType type;
+    };
+
+    explicit InternalExtractorEdge()
+        : result(0, 0, 0, 0, false, false, false, false,
+                TRAVEL_MODE_INACCESSIBLE, false)
     {
     }
 
-    explicit InternalExtractorEdge(NodeID start,
+    explicit InternalExtractorEdge(NodeID source,
                                    NodeID target,
-                                   short direction,
-                                   double speed,
-                                   unsigned name_id,
-                                   bool is_roundabout,
-                                   bool is_in_tiny_cc,
-                                   bool is_duration_set,
-                                   bool is_access_restricted,
+                                   NodeID name_id,
+                                   WeightData weight_data,
+                                   bool forward,
+                                   bool backward,
+                                   bool roundabout,
+                                   bool access_restricted,
                                    TravelMode travel_mode,
                                    bool is_split)
-        : start(start), target(target), speed(speed), name_id(name_id), direction(direction),
-          is_roundabout(is_roundabout), is_in_tiny_cc(is_in_tiny_cc),
-          is_duration_set(is_duration_set), is_access_restricted(is_access_restricted),
-          is_split(is_split), travel_mode(travel_mode)
+        : result(source,
+                 target,
+                 name_id,
+                 0,
+                 forward,
+                 backward,
+                 roundabout,
+                 access_restricted,
+                 travel_mode,
+                 is_split),
+          weight_data(std::move(weight_data))
     {
     }
 
+    // data that will be written to disk
+    NodeBasedEdge result;
+    // intermediate edge weight
+    WeightData weight_data;
+    // coordinate of the source node
+    FixedPointCoordinate source_coordinate;
+
+
     // necessary static util functions for stxxl's sorting
     static InternalExtractorEdge min_value()
     {
-        return InternalExtractorEdge(0, 0, 0, 0, 0, false, false, false, false,
-                                     TRAVEL_MODE_INACCESSIBLE, false);
+        return InternalExtractorEdge(0, 0, 0, WeightData(), false, false, false,
+                                     false, TRAVEL_MODE_INACCESSIBLE, false);
     }
     static InternalExtractorEdge max_value()
     {
-        return InternalExtractorEdge(SPECIAL_NODEID, SPECIAL_NODEID, 0, 0, 0, false, false, false,
-                                     false, TRAVEL_MODE_INACCESSIBLE, false);
+        return InternalExtractorEdge(SPECIAL_NODEID, SPECIAL_NODEID, 0, WeightData(), false,
+                                     false, false, false, TRAVEL_MODE_INACCESSIBLE, false);
+    }
+};
+
+struct CmpEdgeByStartThenTargetID
+{
+    using value_type = InternalExtractorEdge;
+    bool operator()(const InternalExtractorEdge &lhs, const InternalExtractorEdge &rhs) const
+    {
+        return (lhs.result.source <  rhs.result.source) ||
+              ((lhs.result.source == rhs.result.source) &&
+               (lhs.result.target <  rhs.result.target));
     }
 
-    NodeID start;
-    NodeID target;
-    double speed;
-    unsigned name_id;
-    short direction;
-    bool is_roundabout : 1;
-    bool is_in_tiny_cc : 1;
-    bool is_duration_set : 1;
-    bool is_access_restricted : 1;
-    bool is_split : 1;
-    TravelMode travel_mode : 4;
-
-    FixedPointCoordinate source_coordinate;
-    FixedPointCoordinate target_coordinate;
+    value_type max_value() { return InternalExtractorEdge::max_value(); }
+    value_type min_value() { return InternalExtractorEdge::min_value(); }
 };
 
 struct CmpEdgeByStartID
 {
     using value_type = InternalExtractorEdge;
-    bool operator()(const InternalExtractorEdge &a, const InternalExtractorEdge &b) const
+    bool operator()(const InternalExtractorEdge &lhs, const InternalExtractorEdge &rhs) const
     {
-        return a.start < b.start;
+        return lhs.result.source < rhs.result.source;
     }
 
     value_type max_value() { return InternalExtractorEdge::max_value(); }
-
     value_type min_value() { return InternalExtractorEdge::min_value(); }
 };
 
 struct CmpEdgeByTargetID
 {
     using value_type = InternalExtractorEdge;
-
-    bool operator()(const InternalExtractorEdge &a, const InternalExtractorEdge &b) const
+    bool operator()(const InternalExtractorEdge &lhs, const InternalExtractorEdge &rhs) const
     {
-        return a.target < b.target;
+        return lhs.result.target < rhs.result.target;
     }
 
     value_type max_value() { return InternalExtractorEdge::max_value(); }
-
     value_type min_value() { return InternalExtractorEdge::min_value(); }
 };
 

extractor/restriction_parser.cpp

@@ -35,6 +35,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/regex.hpp>
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/ref.hpp>
 #include <boost/regex.hpp>
 
@@ -44,15 +45,14 @@ namespace
 {
 int lua_error_callback(lua_State *lua_state)
 {
-    luabind::object error_msg(luabind::from_stack(lua_state, -1));
+    std::string error_msg = lua_tostring(lua_state, -1);
     std::ostringstream error_stream;
     error_stream << error_msg;
     throw osrm::exception("ERROR occured in profile script:\n" + error_stream.str());
 }
 }
 
-RestrictionParser::RestrictionParser(lua_State *lua_state)
-    : use_turn_restrictions(true)
+RestrictionParser::RestrictionParser(lua_State *lua_state) : use_turn_restrictions(true)
 {
     ReadUseRestrictionsSetting(lua_state);
 
@@ -141,16 +141,30 @@ RestrictionParser::TryParse(const osmium::Relation &relation) const
 
     bool is_only_restriction = false;
 
-    for (auto iter = fi_begin; iter != fi_end; ++iter)
+    for (; fi_begin != fi_end; ++fi_begin)
     {
-        if (std::string("restriction") == iter->key() ||
-            std::string("restriction::hgv") == iter->key())
-        {
-            const std::string restriction_value(iter->value());
+        const std::string key(fi_begin->key());
+        const std::string value(fi_begin->value());
 
-            if (restriction_value.find("only_") == 0)
+        if (value.find("only_") == 0)
+        {
+            is_only_restriction = true;
+        }
+
+        // if the "restriction*" key is longer than 11 chars, it is a conditional exception (i.e.
+        // "restriction:<transportation_type>")
+        if (key.size() > 11)
+        {
+            const auto ex_suffix = [&](const std::string &exception)
             {
-                is_only_restriction = true;
+                return boost::algorithm::ends_with(key, exception);
+            };
+            bool is_actually_restricted =
+                std::any_of(begin(restriction_exceptions), end(restriction_exceptions), ex_suffix);
+
+            if (!is_actually_restricted)
+            {
+                return mapbox::util::optional<InputRestrictionContainer>();
             }
         }
     }

extractor/scripting_environment.cpp

@@ -30,13 +30,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "extraction_helper_functions.hpp"
 #include "extraction_node.hpp"
 #include "extraction_way.hpp"
+#include "internal_extractor_edge.hpp"
 #include "../data_structures/external_memory_node.hpp"
+#include "../data_structures/raster_source.hpp"
 #include "../util/lua_util.hpp"
 #include "../util/osrm_exception.hpp"
 #include "../util/simple_logger.hpp"
 #include "../typedefs.h"
 
 #include <luabind/tag_function.hpp>
+#include <luabind/operator.hpp>
 
 #include <osmium/osm.hpp>
 
@@ -53,7 +56,7 @@ auto get_value_by_key(T const &object, const char *key) -> decltype(object.get_v
 int lua_error_callback(lua_State *L) // This is so I can use my own function as an
 // exception handler, pcall_log()
 {
-    luabind::object error_msg(luabind::from_stack(L, -1));
+    std::string error_msg = lua_tostring(L, -1);
     std::ostringstream error_stream;
     error_stream << error_msg;
     throw osrm::exception("ERROR occured in profile script:\n" + error_stream.str());
@@ -80,6 +83,13 @@ void ScriptingEnvironment::init_lua_state(lua_State *lua_state)
         luabind::def("print", LUA_print<std::string>),
         luabind::def("durationIsValid", durationIsValid),
         luabind::def("parseDuration", parseDuration),
+        luabind::class_<SourceContainer>("sources")
+            .def(luabind::constructor<>())
+            .def("load", &SourceContainer::loadRasterSource)
+            .def("query", &SourceContainer::getRasterDataFromSource)
+            .def("interpolate", &SourceContainer::getRasterInterpolateFromSource),
+        luabind::class_<const float>("constants")
+            .enum_("enums")[luabind::value("precision", COORDINATE_PRECISION)],
 
         luabind::class_<std::vector<std::string>>("vector")
             .def("Add", static_cast<void (std::vector<std::string>::*)(const std::string &)>(
@@ -107,7 +117,6 @@ void ScriptingEnvironment::init_lua_state(lua_State *lua_state)
             .def_readwrite("name", &ExtractionWay::name)
             .def_readwrite("roundabout", &ExtractionWay::roundabout)
             .def_readwrite("is_access_restricted", &ExtractionWay::is_access_restricted)
-            .def_readwrite("ignore_in_index", &ExtractionWay::ignore_in_grid)
             .def_readwrite("duration", &ExtractionWay::duration)
             .property("forward_mode", &ExtractionWay::get_forward_mode,
                       &ExtractionWay::set_forward_mode)
@@ -122,7 +131,21 @@ void ScriptingEnvironment::init_lua_state(lua_State *lua_state)
         luabind::class_<osmium::Way>("Way")
             .def("get_value_by_key", &osmium::Way::get_value_by_key)
             .def("get_value_by_key", &get_value_by_key<osmium::Way>)
-            .def("id", &osmium::Way::id)
+            .def("id", &osmium::Way::id),
+        luabind::class_<InternalExtractorEdge>("EdgeSource")
+            .property("source_coordinate", &InternalExtractorEdge::source_coordinate)
+            .property("weight_data", &InternalExtractorEdge::weight_data),
+        luabind::class_<InternalExtractorEdge::WeightData>("WeightData")
+            .def_readwrite("speed", &InternalExtractorEdge::WeightData::speed),
+        luabind::class_<ExternalMemoryNode>("EdgeTarget")
+            .property("lat", &ExternalMemoryNode::lat)
+            .property("lon", &ExternalMemoryNode::lon),
+        luabind::class_<FixedPointCoordinate>("Coordinate")
+            .property("lat", &FixedPointCoordinate::lat)
+            .property("lon", &FixedPointCoordinate::lon),
+        luabind::class_<RasterDatum>("RasterDatum")
+            .property("datum", &RasterDatum::datum)
+            .def("invalid_data", &RasterDatum::get_invalid)
     ];
 
     if (0 != luaL_dofile(lua_state, file_name.c_str()))

features/bicycle/access.feature

@@ -120,7 +120,7 @@ Feature: Bike - Access tags on ways
             | no           |              |              |       |
             | private      |              |              |       |
             | agricultural |              |              |       |
-            | forestery    |              |              |       |
+            | forestry     |              |              |       |
             |              | yes          |              | x     |
             |              | permissive   |              | x     |
             |              | designated   |              | x     |
@@ -128,7 +128,7 @@ Feature: Bike - Access tags on ways
             |              | no           |              |       |
             |              | private      |              |       |
             |              | agricultural |              |       |
-            |              | forestery    |              |       |
+            |              | forestry     |              |       |
             |              |              | yes          | x     |
             |              |              | permissive   | x     |
             |              |              | designated   | x     |
@@ -136,7 +136,7 @@ Feature: Bike - Access tags on ways
             |              |              | no           |       |
             |              |              | private      |       |
             |              |              | agricultural |       |
-            |              |              | forestery    |       |
+            |              |              | forestry     |       |
 
     Scenario: Bike - Access tags on both node and way
         Then routability should be

features/bicycle/access_node.feature

@@ -7,20 +7,21 @@ Feature: Bike - Access tags on nodes
 
     Scenario: Bike - Access tag hierachy on nodes
         Then routability should be
-            | node/access | node/vehicle | node/bicycle | bothw |
-            |             |              |              | x     |
-            | yes         |              |              | x     |
-            | no          |              |              |       |
-            |             | yes          |              | x     |
-            |             | no           |              |       |
-            | no          | yes          |              | x     |
-            | yes         | no           |              |       |
-            |             |              | yes          | x     |
-            |             |              | no           |       |
-            | no          |              | yes          | x     |
-            | yes         |              | no           |       |
-            |             | no           | yes          | x     |
-            |             | yes          | no           |       |
+            | node/access | node/vehicle | node/bicycle | node/highway  | bothw |
+            |             |              |              |               | x     |
+            | yes         |              |              |               | x     |
+            | no          |              |              |               |       |
+            |             | yes          |              |               | x     |
+            |             | no           |              |               |       |
+            | no          | yes          |              |               | x     |
+            | yes         | no           |              |               |       |
+            |             |              | yes          |               | x     |
+            |             |              | no           |               |       |
+            |             |              | no           | crossing      | x     |
+            | no          |              | yes          |               | x     |
+            | yes         |              | no           |               |       |
+            |             | no           | yes          |               | x     |
+            |             | yes          | no           |               |       |
 
     Scenario: Bike - Overwriting implied acccess on nodes doesn't overwrite way
         Then routability should be
@@ -45,7 +46,7 @@ Feature: Bike - Access tags on nodes
             | no           |              |              |       |
             | private      |              |              |       |
             | agricultural |              |              |       |
-            | forestery    |              |              |       |
+            | forestry     |              |              |       |
             |              | yes          |              | x     |
             |              | permissive   |              | x     |
             |              | designated   |              | x     |
@@ -53,7 +54,7 @@ Feature: Bike - Access tags on nodes
             |              | no           |              |       |
             |              | private      |              |       |
             |              | agricultural |              |       |
-            |              | forestery    |              |       |
+            |              | forestry     |              |       |
             |              |              | yes          | x     |
             |              |              | permissive   | x     |
             |              |              | designated   | x     |
@@ -61,4 +62,4 @@ Feature: Bike - Access tags on nodes
             |              |              | no           |       |
             |              |              | private      |       |
             |              |              | agricultural |       |
-            |              |              | forestery    |       |
+            |              |              | forestry     |       |

features/bicycle/barrier.feature

@@ -19,6 +19,7 @@ Feature: Barriers
             | wall           |       |
             | fence          |       |
             | some_tag       |       |
+            | block          | x     |
 
     Scenario: Bike - Access tag trumphs barriers
         Then routability should be

features/bicycle/bridge.feature

@@ -42,6 +42,6 @@ Feature: Bicycle - Handle movable bridge
         When I route I should get
             | from | to | route       | modes | speed   |
             | a    | g  | abc,cde,efg | 1,5,1 | 5 km/h |
-            | b    | f  | abc,cde,efg | 1,5,1 | 3 km/h |
+            | b    | f  | abc,cde,efg | 1,5,1 | 4 km/h |
             | c    | e  | cde         | 5     | 2 km/h |
             | e    | c  | cde         | 5     | 2 km/h |

features/bicycle/surface.feature

@@ -16,7 +16,7 @@ Feature: Bike - Surfaces
             | cycleway | unpaved               | 120s  |
             | cycleway | fine_gravel           | 120s  |
             | cycleway | gravel                | 120s  |
-            | cycleway | pebbelstone           | 120s  |
+            | cycleway | pebblestone           | 120s  |
             | cycleway | dirt                  | 120s  |
             | cycleway | earth                 | 120s  |
             | cycleway | grass                 | 120s  |

features/car/access.feature

@@ -125,13 +125,15 @@ Feature: Car - Restricted access
 
     Scenario: Car - Access combinations
         Then routability should be
-            | highway     | accesss      | vehicle    | motor_vehicle | motorcar   | bothw |
-            | runway      | private      |            |               | permissive | x     |
-            | primary     | forestry     |            | yes           |            | x     |
-            | cycleway    |              |            | designated    |            | x     |
-            | residential |              | yes        | no            |            |       |
-            | motorway    | yes          | permissive |               | private    |       |
-            | trunk       | agricultural | designated | permissive    | no         |       |
+            | highway     | accesss      | vehicle    | motor_vehicle | motorcar    | bothw |
+            | runway      | private      |            |               | permissive  | x     |
+            | primary     | forestry     |            | yes           |             | x     |
+            | cycleway    |              |            | designated    |             | x     |
+            | residential |              | yes        | no            |             |       |
+            | motorway    | yes          | permissive |               | private     |       |
+            | trunk       | agricultural | designated | permissive    | no          |       |
+            | pedestrian  |              |            |               |             |       |
+            | pedestrian  |              |            |               | destination | x     |
 
     Scenario: Car - Ignore access tags for other modes
         Then routability should be

features/car/barrier.feature

@@ -19,6 +19,7 @@ Feature: Car - Barriers
             | wall           |       |
             | fence          |       |
             | some_tag       |       |
+            | block          |       |
 
     Scenario: Car - Access tag trumphs barriers
         Then routability should be
@@ -37,3 +38,10 @@ Feature: Car - Barriers
             | wall         | no            |       |
             | wall         | private       |       |
             | wall         | agricultural  |       |
+
+    Scenario: Car - Rising bollard exception for barriers
+        Then routability should be
+            | node/barrier | node/bollard  | bothw |
+            | bollard      |               |       |
+            | bollard      | rising        | x     |
+            | bollard      | removable     |       |

features/car/bridge.feature

@@ -41,7 +41,7 @@ Feature: Car - Handle movable bridge
 
         When I route I should get
             | from | to | route       | modes | speed   |
-            | a    | g  | abc,cde,efg | 1,3,1 | 6 km/h |
-            | b    | f  | abc,cde,efg | 1,3,1 | 4 km/h |
+            | a    | g  | abc,cde,efg | 1,3,1 | 7 km/h |
+            | b    | f  | abc,cde,efg | 1,3,1 | 5 km/h |
             | c    | e  | cde         | 3     | 2 km/h |
             | e    | c  | cde         | 3     | 2 km/h |

features/car/ferry.feature

@@ -41,7 +41,7 @@ Feature: Car - Handle ferry routes
 
         When I route I should get
             | from | to | route       | modes | speed   |
-            | a    | g  | abc,cde,efg | 1,2,1 | 26 km/h |
+            | a    | g  | abc,cde,efg | 1,2,1 | 25 km/h |
             | b    | f  | abc,cde,efg | 1,2,1 | 20 km/h |
             | c    | e  | cde         | 2     | 12 km/h |
             | e    | c  | cde         | 2     | 12 km/h |
@@ -60,7 +60,7 @@ Feature: Car - Handle ferry routes
 
         When I route I should get
             | from | to | route       | modes | speed   |
-            | a    | g  | abc,cde,efg | 1,2,1 | 26 km/h |
+            | a    | g  | abc,cde,efg | 1,2,1 | 25 km/h |
             | b    | f  | abc,cde,efg | 1,2,1 | 20 km/h |
             | c    | e  | cde         | 2     | 12 km/h |
             | e    | c  | cde         | 2     | 12 km/h |

features/car/maxspeed.feature

@@ -23,10 +23,10 @@ OSRM will use 4/5 of the projected free-flow speed.
             | from | to | route | speed         |
             | a    | b  | ab    |  78 km/h      |
             | b    | c  | bc    |  59 km/h +- 1 |
-            | c    | d  | cd    |  50 km/h      |
+            | c    | d  | cd    |  51 km/h      |
             | d    | e  | de    |  75 km/h      |
             | e    | f  | ef    |  90 km/h      |
-            | f    | g  | fg    | 105 km/h      |
+            | f    | g  | fg    | 106 km/h      |
 
     Scenario: Car - Do not ignore maxspeed when higher than way speed
         Given the node map
@@ -42,7 +42,7 @@ OSRM will use 4/5 of the projected free-flow speed.
             | from | to | route | speed        |
             | a    | b  | ab    | 31 km/h      |
             | b    | c  | bc    | 83 km/h +- 1 |
-            | c    | d  | cd    | 50 km/h      |
+            | c    | d  | cd    | 51 km/h      |
 
     Scenario: Car - Forward/backward maxspeed
         Given a grid size of 100 meters
@@ -93,3 +93,29 @@ OSRM will use 4/5 of the projected free-flow speed.
             | primary | 15       |       | 30               | 60                | 34 km/h | 59 km/h |
             | primary | 15       |   3   | 30               | 60                | 15 km/h | 30 km/h |
 
+    Scenario: Car - Single lane streets be ignored or incur a penalty
+        Then routability should be
+
+            | highway | maxspeed | lanes | maxspeed:forward | maxspeed:backward | forw    | backw   |
+            | primary |          |       |                  |                   | 63 km/h | 63 km/h |
+            | primary |          |   1   |                  |                   | 32 km/h | 32 km/h |
+            | primary | 60       |       |                  |                   | 59 km/h | 59 km/h |
+            | primary | 60       |   1   |                  |                   | 30 km/h | 30 km/h |
+            | primary |          |       | 60               |                   | 59 km/h | 63 km/h |
+            | primary |          |   1   | 60               |                   | 30 km/h | 32 km/h |
+            | primary |          |       |                  | 60                | 63 km/h | 59 km/h |
+            | primary |          |   1   |                  | 60                | 32 km/h | 30 km/h |
+            | primary | 15       |       | 60               |                   | 59 km/h | 23 km/h |
+            | primary | 15       |   1   | 60               |                   | 30 km/h |  7 km/h |
+            | primary | 15       |       |                  | 60                | 23 km/h | 59 km/h |
+            | primary | 15       |   1   |                  | 60                |  7 km/h | 30 km/h |
+            | primary | 15       |       | 30               | 60                | 34 km/h | 59 km/h |
+            | primary | 15       |   1   | 30               | 60                | 15 km/h | 30 km/h |
+
+    Scenario: Car - Single lane streets only incure a penalty for two-way streets
+        Then routability should be
+            | highway | maxspeed | lanes  | oneway | forw    | backw   |
+            | primary |   30     |   1    | yes    | 34 km/h |         |
+            | primary |   30     |   1    | -1     |         | 34 km/h |
+            | primary |   30     |   1    |        | 15 km/h | 15 km/h |
+            | primary |   30     |   2    |        | 34 km/h | 34 km/h |

features/car/names.feature

@@ -10,13 +10,13 @@ Feature: Car - Street names in instructions
             |   | c |
 
         And the ways
-            | nodes | name     |
-            | ab    | My Way   |
-            | bc    | Your Way |
+            | nodes | name     | ref |
+            | ab    | My Way   |     |
+            | bc    | Your Way | A1  |
 
         When I route I should get
-            | from | to | route           |
-            | a    | c  | My Way,Your Way |
+            | from | to | route                |
+            | a    | c  | My Way,Your Way (A1) |
 
     @todo
     Scenario: Car - Use way type to describe unnamed ways

features/car/restrictions.feature

@@ -226,6 +226,54 @@ Feature: Car - Turn restrictions
             | s    | n  | sj,nj |
             | s    | e  |       |
 
+    @specific
+    Scenario: Car - :hgv-qualified on a standard turn restriction
+        Given the node map
+            |   | n |   |
+            | w | j | e |
+            |   | s |   |
+
+        And the ways
+            | nodes | oneway |
+            | sj    | yes    |
+            | nj    | -1     |
+            | wj    | -1     |
+            | ej    | -1     |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:hgv |
+            | restriction | sj       | nj     | j        | no_straight_on  |
+
+        When I route I should get
+            | from | to | route |
+            | s    | w  | sj,wj |
+            | s    | n  | sj,nj |
+            | s    | e  | sj,ej |
+
+    @specific
+    Scenario: Car - :motorcar-qualified on a standard turn restriction
+        Given the node map
+            |   | n |   |
+            | w | j | e |
+            |   | s |   |
+
+        And the ways
+            | nodes | oneway |
+            | sj    | yes    |
+            | nj    | -1     |
+            | wj    | -1     |
+            | ej    | -1     |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:motorcar |
+            | restriction | sj       | nj     | j        | no_straight_on       |
+
+        When I route I should get
+            | from | to | route |
+            | s    | w  | sj,wj |
+            | s    | n  |       |
+            | s    | e  | sj,ej |
+
     @except
     Scenario: Car - Except tag and on no_ restrictions
         Given the node map

features/foot/access.feature

@@ -51,7 +51,7 @@ Feature: Foot - Access tags on ways
             | no           |              |       |
             | private      |              |       |
             | agricultural |              |       |
-            | forestery    |              |       |
+            | forestry     |              |       |
             |              | yes          | x     |
             |              | permissive   | x     |
             |              | designated   | x     |
@@ -59,7 +59,7 @@ Feature: Foot - Access tags on ways
             |              | no           |       |
             |              | private      |       |
             |              | agricultural |       |
-            |              | forestery    |       |
+            |              | forestry     |       |
 
     Scenario: Foot - Access tags on both node and way
         Then routability should be

features/foot/access_node.feature

@@ -39,7 +39,7 @@ Feature: Foot - Access tags on nodes
             | no           |              |       |
             | private      |              |       |
             | agricultural |              |       |
-            | forestery    |              |       |
+            | forestry     |              |       |
             | no           | yes          | x     |
             | no           | permissive   | x     |
             | no           | designated   | x     |
@@ -47,4 +47,4 @@ Feature: Foot - Access tags on nodes
             | yes          | no           |       |
             | yes          | private      |       |
             | yes          | agricultural |       |
-            | yes          | forestery    |       |
+            | yes          | forestry     |       |

features/foot/barrier.feature

@@ -19,6 +19,7 @@ Feature: Barriers
             | wall           |       |
             | fence          |       |
             | some_tag       |       |
+            | block          | x     |
 
     Scenario: Foot - Access tag trumphs barriers
         Then routability should be

features/foot/surface.feature

@@ -10,6 +10,6 @@ Feature: Foot - Surfaces
             | footway |             | 145s ~10% |
             | footway | fine_gravel | 193s ~10% |
             | footway | gravel      | 193s ~10% |
-            | footway | pebbelstone | 193s ~10% |
+            | footway | pebblestone | 193s ~10% |
             | footway | mud         | 289s ~10% |
             | footway | sand        | 289s ~10% |

features/foot/way.feature

@@ -30,3 +30,9 @@ Feature: Foot - Accessability of different way types
             | pier           | x    |
             | cycleway       |      |
             | bridleway      |      |
+
+    Scenario: Foot - Basic access
+        Then routability should be
+            | highway | leisure  | forw |
+            | (nil)   | track    |   x  |
+