Tag a new latest version for publishing

Always check local variables
Update releasing docs
2017-04-03 12:50:45 +00:00 · 2017-03-30 20:12:07 +00:00 · 2017-03-30 20:12:07 +00:00 · 2017-03-30 20:12:07 +00:00 · 2017-03-30 20:12:07 +00:00 · 2017-03-30 20:12:07 +00:00
53 changed files with 7485 additions and 429 deletions
@@ -7,14 +7,20 @@ git:
 sudo: required
 dist: trusty

+nodejs:
+    - "4"
+
 notifications:
  email: false

 branches:
  only:
    - master
+    # enable building tags
+    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/

 cache:
+  yarn: true
  ccache: true
  apt: true
  directories:
@@ -22,6 +28,8 @@ cache:

 env:
  global:
+   - secure: "hk+32aXXF5t1ApaM2Wjqooz3dx1si907L87WRMkO47WlpJmUUU/Ye+MJk9sViH8MdhOcceocVAmdYl5/WFWOIbDWNlBya9QvXDZyIu2KIre/0QyOCTZbrsif8paBXKIO5O/R4OTvIZ8rvWZsadBdmAT9GSbDhih6FzqXAEgeIYQ="
+   - secure: "VE+cFkseFwW4jK6XwkP0yW3h4DixPJ8+Eb3yKcchGZ5iIJxlZ/8i1vKHYxadgPRwSYwPSB14tF70xj2OmiT2keGzZUfphmPXinBaLEhYk+Bde+GZZkoSl5ND109I/LcyNr0nG9dDgtV6pkvFchgchpyP9JnVOOS0+crEZlAz0RE="
   - CCACHE_TEMPDIR=/tmp/.ccache-temp
   - CCACHE_COMPRESS=1
   - CASHER_TIME_OUT=599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
@@ -138,11 +146,12 @@ before_install:
    if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
      export JOBS=$((`sysctl -n hw.ncpu` + 1))
      sudo mdutil -i off /
+      npm install -g yarn
    fi
+  - export PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
+  - export PUBLISH=$([[ "${TRAVIS_TAG:-}" == "v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off")
  - echo "Using ${JOBS} jobs"
-  - source ./scripts/install_node.sh 4
-  - npm install -g "npm@>=3" # Upgrade to npm >v2 to reduce size of downloaded dependencies
-  - npm install --ignore-scripts
+  - yarn install --ignore-scripts
    # Bootstrap cmake to be able to run mason
  - CMAKE_URL="https://mason-binaries.s3.amazonaws.com/${TRAVIS_OS_NAME}-x86_64/cmake/${CMAKE_VERSION}.tar.gz"
  - CMAKE_DIR="mason_packages/${TRAVIS_OS_NAME}-x86_64/cmake/${CMAKE_VERSION}"
@@ -173,7 +182,16 @@ install:
  - export OSRM_BUILD_DIR="$(pwd)/build-osrm"
  - mkdir ${OSRM_BUILD_DIR} && pushd ${OSRM_BUILD_DIR}
  - export CC=${CCOMPILER} CXX=${CXXCOMPILER}
-  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_MASON=${ENABLE_MASON:-OFF} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} -DBUILD_TOOLS=ON -DENABLE_CCACHE=ON -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF}
+  - |
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+             -DENABLE_MASON=${ENABLE_MASON:-OFF} \
+             -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} \
+             -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} \
+             -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} \
+             -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
+             -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
+             -DBUILD_TOOLS=ON \
+             -DENABLE_CCACHE=ON
  - echo "travis_fold:start:MAKE"
  - make --jobs=${JOBS}
  - make tests --jobs=${JOBS}
@@ -190,7 +208,8 @@ install:
  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
  - make --jobs=${JOBS}
  - popd
-  - npm run build-api-docs
+  # building docs only works with npm3+ not with yarn or npm2
+  #- yarn run docs

 script:
  - if [[ $TARGET_ARCH == armhf ]] ; then echo "Skip tests for $TARGET_ARCH" && exit 0 ; fi
@@ -205,7 +224,7 @@ script:
  - ./unit_tests/server-tests
  - ./unit_tests/partition-tests
  - popd
-  - npm test
+  - yarn test

 after_success:
  - |
@@ -215,8 +234,5 @@ after_success:

  - |
    if [ -n "${ENABLE_NODE_BINDINGS}" ]; then
-      nvm install 4
-      nvm use 4
-      source ./scripts/travis/build.sh
      ./scripts/travis/publish.sh
    fi
@@ -1,3 +1,5 @@
+- Track preprocessing flag in the map matching plugin.
+
 # 5.7.0
  - Changes from 5.6
    - NodeJs Bindings
@@ -8,6 +10,8 @@
      - .osrm.datasource_index file was removed. Data is now part of .osrm.geometries.
      - .osrm.edge_lookup was removed. The option `--generate-edge-lookup` does nothing now.
      - `osrm-contract` does not depend on the `.osrm.fileIndex` file anymore
+    - Profiles
+      - Added `force_split_edges` flag to global properties. True value guarantees that segment_function will be called for all segments, but also could double memory consumption

 # 5.6.3
  - Changes from 5.6.0
@@ -41,19 +41,27 @@ The easiest and quickest way to setup your own routing engine backend is to use

 ### Using Docker

-We base the Docker images on Alpine Linux and make sure they are as lightweight as possible (around 10-15 MB).
-In the following, replace `X.Y.Z` with the current stable release version.
+We base [our Docker images](https://hub.docker.com/r/osrm/osrm-backend/) on Alpine Linux and make sure they are as lightweight as possible.

 ```
 wget http://download.geofabrik.de/europe/germany/berlin-latest.osm.pbf

-docker run -t -v $(pwd):/data osrm/osrm-backend:vX.Y.Z osrm-extract -p /opt/car.lua /data/berlin-latest.osm.pbf
-docker run -t -v $(pwd):/data osrm/osrm-backend:vX.Y.Z osrm-contract /data/berlin-latest.osrm
-docker run -t -i -p 5000:5000 -v $(pwd):/data osrm/osrm-backend:vX.Y.Z osrm-routed /data/berlin-latest.osrm
+docker run -t -v $(pwd):/data osrm/osrm-backend osrm-extract -p /opt/car.lua /data/berlin-latest.osm.pbf
+docker run -t -v $(pwd):/data osrm/osrm-backend osrm-contract /data/berlin-latest.osrm
+docker run -t -i -p 5000:5000 -v $(pwd):/data osrm/osrm-backend osrm-routed /data/berlin-latest.osrm

-curl http://127.0.0.1:5000/route/v1/driving/13.388860,52.517037;13.385983,52.496891?steps=true
+curl "http://127.0.0.1:5000/route/v1/driving/13.388860,52.517037;13.385983,52.496891?steps=true"
 ```

+In case Docker complains about not being able to connect to the Docker daemon make sure you are in the `docker` group.
+
+```
+sudo usermod -aG docker $USER
+```
+
+After adding yourself to the `docker` group make sure to log out and back in again with your terminal.
+
+
 ### Building from Source

 The following targets Ubuntu 16.04.
@@ -141,15 +141,21 @@ SET test_osm=%test_region%.osm.pbf
 IF NOT EXIST %test_osm% powershell Invoke-WebRequest https://s3.amazonaws.com/mapbox/osrm/testing/monaco.osm.pbf -OutFile %test_osm%
 %Configuration%\osrm-extract.exe -p ../profiles/car.lua %test_osm%
 MKDIR ch
-XCOPY %test_region%.osrm %test_region%.osrm.* ch\
+XCOPY %test_region%.osrm.* ch\
+XCOPY %test_region%.osrm ch\
 MKDIR corech
-XCOPY %test_region%.osrm %test_region%.osrm.* corech\
+XCOPY %test_region%.osrm.* corech\
+XCOPY %test_region%.osrm corech\
 MKDIR mld
-XCOPY %test_region%.osrm %test_region%.osrm.* mld\
+XCOPY %test_region%.osrm.* mld\
+XCOPY %test_region%.osrm mld\
 %Configuration%\osrm-contract.exe %test_region_ch%.osrm
 %Configuration%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
 %Configuration%\osrm-partition.exe %test_region_mld%.osrm
 %Configuration%\osrm-customize.exe %test_region_mld%.osrm
+XCOPY /Y ch\*.* ..\test\data\ch\
+XCOPY /Y corech\*.* ..\test\data\corech\
+XCOPY /Y mld\*.* ..\test\data\mld\
 unit_tests\%Configuration%\library-tests.exe

 IF NOT "%APPVEYOR_REPO_BRANCH%"=="master" GOTO DONE
@@ -0,0 +1,75 @@
+{
+    "AWSTemplateFormatVersion": "2010-09-09",
+    "Description": "user for publishing to s3://mapbox-node-binary/osrm",
+    "Resources": {
+        "User": {
+            "Type": "AWS::IAM::User",
+            "Properties": {
+                "Policies": [
+                    {
+                        "PolicyName": "list",
+                        "PolicyDocument": {
+                            "Statement": [
+                                {
+                                    "Action": [
+                                        "s3:ListBucket"
+                                    ],
+                                    "Effect": "Allow",
+                                    "Resource": "arn:aws:s3:::mapbox-node-binary",
+                                    "Condition": {
+                                        "StringLike": {
+                                            "s3:prefix": [
+                                                "osrm/*"
+                                            ]
+                                        }
+                                    }
+                                }
+                            ]
+                        }
+                    },
+                    {
+                        "PolicyName": "publish",
+                        "PolicyDocument": {
+                            "Statement": [
+                                {
+                                    "Action": [
+                                        "s3:DeleteObject",
+                                        "s3:GetObject",
+                                        "s3:GetObjectAcl",
+                                        "s3:PutObject",
+                                        "s3:PutObjectAcl"
+                                    ],
+                                    "Effect": "Allow",
+                                    "Resource": "arn:aws:s3:::mapbox-node-binary/osrm/*"
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        },
+        "AccessKey": {
+            "Type": "AWS::IAM::AccessKey",
+            "Properties": {
+                "UserName": {
+                    "Ref": "User"
+                }
+            }
+        }
+    },
+    "Outputs": {
+        "AccessKeyId": {
+            "Value": {
+                "Ref": "AccessKey"
+            }
+        },
+        "SecretAccessKey": {
+            "Value": {
+                "Fn::GetAtt": [
+                    "AccessKey",
+                    "SecretAccessKey"
+                ]
+            }
+        }
+    }
+}
@@ -0,0 +1,59 @@
+var cf = require('@mapbox/cloudfriend');
+var package_json = require('../package.json')
+
+module.exports = {
+  AWSTemplateFormatVersion: '2010-09-09',
+  Description: 'user for publishing to s3://mapbox-node-binary/' + package_json.name,
+  Resources: {
+    User: {
+      Type: 'AWS::IAM::User',
+      Properties: {
+        Policies: [
+          {
+            PolicyName: 'list',
+            PolicyDocument: {
+              Statement: [
+                {
+                  Action: ['s3:ListBucket'],
+                  Effect: 'Allow',
+                  Resource: 'arn:aws:s3:::mapbox-node-binary',
+                  Condition : {
+                    StringLike : {
+                      "s3:prefix": [ package_json.name + "/*"]
+                    }
+                  }
+                }
+              ]
+            }
+          },
+          {
+            PolicyName: 'publish',
+            PolicyDocument: {
+              Statement: [
+                {
+                  Action: ['s3:DeleteObject', 's3:GetObject', 's3:GetObjectAcl', 's3:PutObject', 's3:PutObjectAcl'],
+                  Effect: 'Allow',
+                  Resource: 'arn:aws:s3:::mapbox-node-binary/' + package_json.name + '/*'
+                }
+              ]
+            }
+          }
+        ]
+      }
+    },
+    AccessKey: {
+      Type: 'AWS::IAM::AccessKey',
+      Properties: {
+        UserName: cf.ref('User')
+      }
+    }
+  },
+  Outputs: {
+    AccessKeyId: {
+      Value: cf.ref('AccessKey')
+    },
+    SecretAccessKey: {
+      Value: cf.getAtt('AccessKey', 'SecretAccessKey')
+    }
+  }
+};
@@ -1,7 +1,6 @@
 coverage:

  ignore:
-    - unit_tests/.*
    - third_party/.*

 comment: off
@@ -279,6 +279,8 @@ In addition to the [general options](#general-options) the following options are
 |overview    |`simplified` (default), `full`, `false`         |Add overview geometry either full, simplified according to highest zoom level it could be display on, or not at all.|
 |timestamps  |`{timestamp};{timestamp}[;{timestamp} ...]`     |Timestamps for the input locations in seconds since UNIX epoch. Timestamps need to be monotonically increasing. |
 |radiuses    |`{radius};{radius}[;{radius} ...]`              |Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy.|
+|gaps        |`split` (default), `ignore`                     |Allows the input track splitting based on huge timestamp gaps between points.             |
+|tidy        |`true`, `false` (default)                       |Allows the input track modification to obtain better matching quality for noisy tracks.   |

 |Parameter   |Values                             |
 |------------|-----------------------------------|
@@ -314,7 +316,7 @@ All other properties might be undefined.

 The trip plugin solves the Traveling Salesman Problem using a greedy heuristic (farthest-insertion algorithm) for 10 or more waypoints and uses brute force for less than 10 waypoints.
 The returned path does not have to be the fastest path. As TSP is NP-hard it only returns an approximation.
-Note that all input coordinates have to be connected for the trip service to work. 
+Note that all input coordinates have to be connected for the trip service to work.

 ```endpoint
 GET /trip/v1/{profile}/{coordinates}?roundtrip={true|false}&source{any|first}&destination{any|last}&steps={true|false}&geometries={polyline|polyline6|geojson}&overview={simplified|full|false}&annotations={true|false}'
@@ -334,7 +336,7 @@ In addition to the [general options](#general-options) the following options are

 **Fixing Start and End Points**

-It is possible to explicitely set the start or end coordinate of the trip. 
+It is possible to explicitely set the start or end coordinate of the trip.
 When source is set to `first`, the first coordinate is used as start coordinate of the trip in the output. When destination is set to `last`, the last coordinate will be used as destination of the trip in the returned output. If you specify `any`, any of the coordinates can be used as the first or last coordinate in the output.

 However, if `source=any&destination=any` the returned round-trip will still start at the first input coordinate by default.
@@ -344,7 +346,7 @@ Right now, the following combinations are possible:

 | roundtrip | source | destination | supported |
 | :-- | :-- | :-- | :-- |
-| true | first | last | **yes** | 
+| true | first | last | **yes** |
 | true | first | any | **yes** |
 | true | any | last | **yes** |
 | true | any | any | **yes** |
@@ -25,6 +25,19 @@ As you scroll down the file you'll see local variables, and then local functions

 `way_function` and `node_function` are the important functions which are called when extracting OpenStreetMap data with `osrm-extract`.

+The following global properties can be set in your profile:
+
+Attribute                     | Type     | Notes
+------------------------------|----------|----------------------------------------------------------------------------
+weight_name                   | String   | Name used in output for the routing weight property (default 'duration')
+weight_precision              | Unsigned | Decimal precision of edge weights (default 1)
+left_hand_driving             | Boolean  | Are vehicles assumed to drive on the left? (used in guidance)
+use_turn_restrictions         | Boolean  | Are turn instructions followed?
+continue_straight_at_waypoint | Boolean  | Must the route continue straight on at a via point, or are U-turns allowed?
+max_speed_for_map_matching    | Float    | Maximum vehicle speed to be assumed in matching (in m/s)
+max_turn_weight               | Float    | Maximum turn penalty weight
+force_split_edges             | Boolean  | True value forces a split of forward and backward edges of extracted ways and guarantees that segment_function will be called for all segments
+
 ## way_function

 Given an OpenStreetMap way, the way_function will either return nothing (meaning we are not going to route over this way at all), or it will set up a result hash to be returned. The most important thing it will do is set the value of `result.forward_speed` and `result.backward_speed` as a suitable integer value representing the speed for traversing the way.
@@ -33,15 +46,79 @@ All other calculations stem from that, including the returned timings in driving

 Using the power of the scripting language you wouldn't typically see something as simple as a `result.forward_speed = 20` line within the way_function. Instead a way_function will examine the tagging (e.g. `way:get_value_by_key("highway")` and many others), process this information in various ways, calling other local functions, referencing the global variables and look-up hashes, before arriving at the result.

-## Guidance
+The following attributes can be set on the result in way_function:
+
+Attribute                               | Type     | Notes
+----------------------------------------|----------|--------------------------------------------------------------------------
+forward_speed                           | Float    | Speed on this way in km/h
+backward_speed                          | Float    |  "   "
+forward_rate                            | Float    | Routing weight, expressed as meters/*weight* (e.g. for a fastest-route weighting, you would want this to be meters/second, so set it to forward_speed/3.6)
+backward_rate                           | Float    |  "   "
+forward_mode                            | Enum     | Mode of travel (e.g. car, ferry). Defined in include/extractor/travel_mode.hpp
+backward_mode                           | Enum     |  "   "
+duration                                | Float    | Alternative setter for duration of the whole way in both directions
+weight                                  | Float    | Alternative setter for weight of the whole way in both directions
+turn_lanes_forward                      | String   | Directions for individual lanes (normalised OSM turn:lanes value)
+turn_lanes_backward                     | String   |  "   "
+forward_restricted                      | Boolean  | Is this a restricted access road? (e.g. private, or deliveries only; used to enable high turn penalty, so that way is only chosen for start/end of route)
+backward_restricted                     | Boolean  |  "   "
+is_startpoint                           | Boolean  | Can a journey start on this way? (e.g. ferry; if false, prevents snapping the start point to this way)
+roundabout                              | Boolean  | Is this part of a roundabout?
+circular                                | Boolean  | Is this part of a non-roundabout circular junction?
+name                                    | String   | Name of the way
+ref                                     | String   | Road number
+pronunciation                           | String   | Name pronunciation
+road_classification.motorway_class      | Boolean  | Guidance: way is a motorway
+road_classification.link_class          | Boolean  | Guidance: way is a slip/link road
+road_classification.road_priority_class | Enum     | Guidance: order in priority list. Defined in include/extractor/guidance/road_classification.hpp
+road_classification.may_be_ignored      | Boolean  | Guidance: way is non-highway
+road_classification.num_lanes           | Unsigned | Guidance: total number of lanes in way
+
+### Guidance

 The guidance parameters in profiles are currently a work in progress. They can and will change.
 Please be aware of this when using guidance configuration possibilities.

-### Road Classification
-
 Guidance uses road classes to decide on when/if to emit specific instructions and to discover which road is obvious when following a route.
 Classification uses three flags and a priority-category.
 The flags indicate whether a road is a motorway (required for on/off ramps), a link type (the ramps itself, if also a motorway) and whether a road may be omittted in considerations (is considered purely for connectivity).
 The priority-category influences the decision which road is considered the obvious choice and which roads can be seen as fork.
 Forks can be emitted between roads of similar priority category only. Obvious choices follow a major priority road, if the priority difference is large.
+
+## node_function
+
+The following attributes can be set on the result in node_function:
+
+Attribute       | Type    | Notes
+----------------|---------|-------------------------------------------------------
+barrier         | Boolean | Is it an impassable barrier?
+traffic_lights  | Boolean | Is it a traffic light (incurs delay in turn_function)?
+
+## segment_function
+
+The following attributes can be read and set on the result in segment_function:
+
+Attribute          | Read/write? | Type    | Notes
+-------------------|-------------|---------|------------------------------------------------------
+source.lon         | Read        | Float   | Co-ordinates of segment start
+source.lat         | Read        | Float   |  "   "
+target.lon         | Read        | Float   | Co-ordinates of segment end
+target.lat         | Read        | Float   |  "   "
+target.distance    | Read        | Float   | Length of segment
+weight             | Read/write  | Float   | Routing weight for this segment
+duration           | Read/write  | Float   | Duration for this segment
+
+## turn_function
+
+The following attributes can be read and set on the result in turn_function:
+
+Attribute          | Read/write? | Type    | Notes
+-------------------|-------------|---------|------------------------------------------------------
+direction_modifier | Read        | Enum    | Geometry of turn. Defined in include/extractor/guidance/turn_instruction.hpp
+turn_type          | Read        | Enum    | Priority of turn. Defined in include/extractor/guidance/turn_instruction.hpp
+has_traffic_light  | Read        | Boolean | Is a traffic light present at this turn?
+source_restricted  | Read        | Boolean | Is it from a restricted access road? (See definition in way_function)
+target_restricted  | Read        | Boolean | Is it to a restricted access road? (See definition in way_function)
+angle              | Read        | Float   | Angle of turn in degrees (0-360: 0=u-turn, 180=straight on)
+duration           | Read/write  | Float   | Penalty to be applied for this turn (duration in deciseconds)
+weight             | Read/write  | Float   | Penalty to be applied for this turn (routing weight)
@@ -32,21 +32,25 @@ We may introduce forward-compatible changes: query parameters and response prope

 - The `master` branch is for the bleeding edge development
 - We create and maintain release branches `x.y` to control the release flow
- We create the release branch once we tagged the final version `x.y.0` version, RCs go on master
+- We create the release branch once we create release branches once we want to release the first RC
+- RCs go in the release branch, commits needs to be cherry-picked from master
 - No minor or major version will be released without a code-equal release candidates
- For quality assurance, release candidates will be run on the demo server for 24 hours before releaseing the version proper
+- For quality assurance, release candidates need to be staged beforing tagging a final release
 - Patch versions may be released without a release candidate
 - We may backport fixes to older versions and release them as patch versions

 ## Releasing a version

 1. Check out the appropriate release branch `x.y`
-2. Make sure all tests are passing (e.g. Travis CI gives you a :thumbs_up:)
-3. Make sure `CHANGELOG.md` is up to date.
-4. Make sure the OSRM version in `CMakeLists.txt` is up to date
-5. Use an annotated tag to mark the release: `git tag vx.y.z -a` Body of the tag description should be the changelog entries.
-6. Use `npm run build-api-docs` to generate the API documentation.  Copy `build/docs/*` to `https://github.com/Project-OSRM/project-osrm.github.com` in the `docs/vN.N.N/api` directory
-6. Push tags and commits: `git push; git push --tags`
-8. Proceede with the `node-osrm` release as [outlined in the repository](https://github.com/Project-OSRM/node-osrm/blob/master/docs/releasing.md).
+2. Make sure `CHANGELOG.md` is up to date.
+3. Make sure the OSRM version in `CMakeLists.txt` is up to date
+4. Make sure the `package.json` is up to date.
+5. Make sure all tests are passing (e.g. Travis CI gives you a :thumbs_up:)
+6. Use an annotated tag to mark the release: `git tag vx.y.z -a` Body of the tag description should be the changelog entries.
+7. Use `npm run build-api-docs` to generate the API documentation.  Copy `build/docs/*` to `https://github.com/Project-OSRM/project-osrm.github.com` in the `docs/vN.N.N/api` directory
+8. Push tags and commits: `git push; git push --tags`
 9. If not a release-candidate: Write a mailing-list post to osrm-talk@openstreetmap.org to announce the release
+10. Wait until the travis build has been completed and check if the node binaries were published by doing:
+    `rm -rf node_modules && npm install` locally.
+11. For final releases run `npm publish` or `npm publish --tag next` for release candidates.

@@ -79,3 +79,19 @@ Feature: Bike - Cycle tracks/lanes
            | residential | lane     | yes    | x    | x     |
            | footway     | lane     | yes    | x    | x     |
            | cycleway    | lane     | yes    | x    | x     |
+
+    Scenario: Bike - Cycleway on oneways, modes
+        Then routability should be
+            | highway     | cycleway | oneway | forw         | backw        |
+            | motorway    | track    | yes    | cycling      |              |
+            | residential | track    | yes    | cycling      | pushing bike |
+            | cycleway    | track    | yes    | cycling      | pushing bike |
+            | footway     | track    | yes    | pushing bike | pushing bike |
+
+    Scenario: Bike - Cycleway on oneways, speeds
+        Then routability should be
+            | highway     | cycleway | oneway | forw       | backw      |
+            | motorway    | track    | yes    | 15 km/h    |            |
+            | residential | track    | yes    | 15 km/h    | 6 km/h     |
+            | cycleway    | track    | yes    | 15 km/h    | 6 km/h     |
+            | footway     | track    | yes    | 6 km/h +-1 | 6 km/h +-1 |
@@ -10,11 +10,11 @@ Feature: osrm-partition command line options: help
        And stdout should contain "--help"
        And stdout should contain "Configuration:"
        And stdout should contain "--threads"
-        And stdout should contain "--min-cell-size"
        And stdout should contain "--balance"
        And stdout should contain "--boundary"
        And stdout should contain "--optimizing-cuts"
        And stdout should contain "--small-component-size"
+        And stdout should contain "--max-cell-sizes"
        And it should exit with an error

    Scenario: osrm-partition - Help, short
@@ -26,11 +26,11 @@ Feature: osrm-partition command line options: help
        And stdout should contain "--help"
        And stdout should contain "Configuration:"
        And stdout should contain "--threads"
-        And stdout should contain "--min-cell-size"
        And stdout should contain "--balance"
        And stdout should contain "--boundary"
        And stdout should contain "--optimizing-cuts"
        And stdout should contain "--small-component-size"
+        And stdout should contain "--max-cell-sizes"
        And it should exit successfully

    Scenario: osrm-partition - Help, long
@@ -42,9 +42,9 @@ Feature: osrm-partition command line options: help
        And stdout should contain "--help"
        And stdout should contain "Configuration:"
        And stdout should contain "--threads"
-        And stdout should contain "--min-cell-size"
        And stdout should contain "--balance"
        And stdout should contain "--boundary"
        And stdout should contain "--optimizing-cuts"
        And stdout should contain "--small-component-size"
+        And stdout should contain "--max-cell-sizes"
        And it should exit successfully
@@ -18,3 +18,15 @@ Feature: osrm-partition command line options: invalid options
        And stderr should contain "option"
        And stderr should contain "fly-me-to-the-moon"
        And it should exit with an error
+
+    Scenario: osrm-partition - Check invalid values
+        When I try to run "osrm-partition --max-cell-sizes 4,6@4,16 fly-me-to-the-moon.osrm"
+        Then stdout should be empty
+        And stderr should contain "is invalid"
+        And it should exit with an error
+
+    Scenario: osrm-partition - Check non-descending order
+        When I try to run "osrm-partition --max-cell-sizes 4,64,16 fly-me-to-the-moon.osrm"
+        Then stdout should be empty
+        And stderr should contain "must be sorted in non-descending order"
+        And it should exit with an error
@@ -2,10 +2,10 @@
 Feature: osrm-extract with a profile containing raster source
    Scenario: osrm-extract on a valid profile
        Given the profile "rasterbot"
-        And the node map
-            """
-            a b
-            """
+        And the node locations
+            | node | lat        | lon      |
+            | a    | 0.1        | 0.1      |
+            | b    | 0.05       | 0.1      |
        And the ways
            | nodes |
            | ab    |
@@ -20,4 +20,6 @@ Feature: osrm-extract with a profile containing raster source
        And the data has been saved to disk
        When I run "osrm-extract {osm_file} -p {profile_file}"
        Then stdout should contain "source loader"
+        Then stdout should contain "slope: 0.0899"
+        Then stdout should contain "slope: -0.0899"
        And it should exit successfully
@@ -50,8 +50,9 @@ Feature: Raster - weights
        And I route I should get
            | from | to | route    | speed   |
            | a    | b  | ab,ab    | 8 km/h  |
-            | a    | c  | ad,dc,dc | 15 km/h |
-            | b    | c  | bc,bc    | 8 km/h  |
+            | b    | a  | ab,ab    | 22 km/h |
+            | a    | c  | ab,bc,bc | 12 km/h |
+            | b    | c  | bc,bc    | 22 km/h |
            | a    | d  | ad,ad    | 15 km/h |
            | d    | c  | dc,dc    | 15 km/h |
            | d    | e  | de,de    | 10 km/h |
@@ -40,6 +40,84 @@ Feature: Basic Map Matching
            | trace | timestamps | matchings |
            | abcd  | 0 1 62 63  | ab,cd     |

+    Scenario: Testbot - Map matching with trace splitting suppression
+        Given the query options
+            | gaps | ignore |
+
+        Given the node map
+            """
+            a b c d
+                e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | abcd  | no     |
+
+        When I match I should get
+            | trace | timestamps | matchings |
+            | abcd  | 0 1 62 63  | abcd      |
+
+    Scenario: Testbot - Map matching with trace tidying. Clean case.
+        Given a grid size of 100 meters
+
+        Given the query options
+            | tidy | true |
+
+        Given the node map
+            """
+            a b c d
+                e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | abcd  | no     |
+
+        When I match I should get
+            | trace | timestamps | matchings |
+            | abcd | 0 10 20 30  | abcd      |
+
+    Scenario: Testbot - Map matching with trace tidying. Dirty case by ts.
+        Given a grid size of 100 meters
+
+        Given the query options
+            | tidy | true |
+
+        Given the node map
+            """
+            a b c d
+                e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | abcd  | no     |
+
+        When I match I should get
+            | trace | timestamps    | matchings |
+            | abacd | 0 10 12 20 30 | abcd      |
+
+    Scenario: Testbot - Map matching with trace tidying. Dirty case by dist.
+        Given a grid size of 8 meters
+
+        Given the query options
+            | tidy | true |
+
+        Given the node map
+            """
+            a q b c d
+                e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | aqbcd | no     |
+
+        When I match I should get
+            | trace | matchings |
+            | abcbd | abbd      |
+
    Scenario: Testbot - Map matching with core factor
        Given the contract extra arguments "--core 0.8"
        Given the node map
@@ -3,7 +3,7 @@ Feature: Multi level routing

    Background:
        Given the profile "testbot"
-        And the partition extra arguments "--min-cell-size 4 --small-component-size 1"
+        And the partition extra arguments "--small-component-size 1 --max-cell-sizes 4,16,64"

    Scenario: Testbot - Multi level routing check partition
        Given the node map
@@ -31,7 +31,7 @@ Feature: Multi level routing
            | be    | primary |

        And the data has been extracted
-        When I run "osrm-partition --min-cell-size 4 --small-component-size 1 {processed_file}"
+        When I run "osrm-partition --max-cell-sizes 4,16 --small-component-size 1 {processed_file}"
        Then it should exit successfully
        And stdout should not contain "level 1 #cells 1 bit size 1"

@@ -57,7 +57,6 @@ Feature: Multi level routing
            | cm    | primary |
            | hj    | primary |
            | kp    | primary |
-        And the partition extra arguments "--min-cell-size 4 --small-component-size 1"

        When I route I should get
            | from | to | route                                 | time   |
@@ -88,7 +87,6 @@ Feature: Multi level routing
            | dim   | primary   |
            | glr   | primary   |
            | ot    | secondary |
-        And the partition extra arguments "--min-cell-size 4 --small-component-size 1"

        When I route I should get
            | from | to | route                          | time |
@@ -113,6 +111,7 @@ Feature: Multi level routing
                          │   │
                          l───k
            """
+        And the partition extra arguments "--small-component-size 1 --max-cell-sizes 4,16"
        And the ways
            | nodes | maxspeed |
            | abcda |        5 |
@@ -124,7 +123,6 @@ Feature: Multi level routing
            | fi    |       15 |
            | gi    |       15 |
            | hf    |      100 |
-        And the partition extra arguments "--min-cell-size 4 --small-component-size 1"

        When I route I should get
            | from | to | route                      | time   |
@@ -39,9 +39,9 @@ class CellCustomizer
                const EdgeWeight weight = heap.GetKey(node);

                if (level == 1)
-                    RelaxNode<true>(graph, cells, heap, level, id, node, weight);
+                    RelaxNode<true>(graph, cells, heap, level, node, weight);
                else
-                    RelaxNode<false>(graph, cells, heap, level, id, node, weight);
+                    RelaxNode<false>(graph, cells, heap, level, node, weight);

                destinations_set.erase(node);
            }
@@ -85,7 +85,6 @@ class CellCustomizer
                   const partition::CellStorage &cells,
                   Heap &heap,
                   LevelID level,
-                   CellID id,
                   NodeID node,
                   EdgeWeight weight) const
    {
@@ -2,6 +2,7 @@
 #define ENGINE_API_MATCH_HPP

 #include "engine/api/match_parameters.hpp"
+#include "engine/api/match_parameters_tidy.hpp"
 #include "engine/api/route_api.hpp"

 #include "engine/datafacade/datafacade_base.hpp"
@@ -21,8 +22,10 @@ namespace api
 class MatchAPI final : public RouteAPI
 {
  public:
-    MatchAPI(const datafacade::BaseDataFacade &facade_, const MatchParameters &parameters_)
-        : RouteAPI(facade_, parameters_), parameters(parameters_)
+    MatchAPI(const datafacade::BaseDataFacade &facade_,
+             const MatchParameters &parameters_,
+             const tidy::Result &tidy_result_)
+        : RouteAPI(facade_, parameters_), parameters(parameters_), tidy_result(tidy_result_)
    {
    }

@@ -83,13 +86,20 @@ class MatchAPI final : public RouteAPI
            for (auto point_index : util::irange(
                     0u, static_cast<unsigned>(sub_matchings[sub_matching_index].indices.size())))
            {
-                trace_idx_to_matching_idx[sub_matchings[sub_matching_index].indices[point_index]] =
+                trace_idx_to_matching_idx[tidy_result
+                                              .tidied_to_original[sub_matchings[sub_matching_index]
+                                                                      .indices[point_index]]] =
                    MatchingIndex{sub_matching_index, point_index};
            }
        }

        for (auto trace_index : util::irange<std::size_t>(0UL, parameters.coordinates.size()))
        {
+            if (tidy_result.can_be_removed[trace_index])
+            {
+                waypoints.values.push_back(util::json::Null());
+                continue;
+            }
            auto matching_index = trace_idx_to_matching_idx[trace_index];
            if (matching_index.NotMatched())
            {
@@ -111,6 +121,7 @@ class MatchAPI final : public RouteAPI
    }

    const MatchParameters &parameters;
+    const tidy::Result &tidy_result;
 };

 } // ns api
@@ -50,23 +50,34 @@ namespace api
 */
 struct MatchParameters : public RouteParameters
 {
+    enum class GapsType
+    {
+        Split,
+        Ignore
+    };
+
    MatchParameters()
        : RouteParameters(false,
                          false,
                          false,
                          RouteParameters::GeometriesType::Polyline,
                          RouteParameters::OverviewType::Simplified,
-                          {})
+                          {}),
+          gaps(GapsType::Split), tidy(false)
    {
    }

    template <typename... Args>
-    MatchParameters(std::vector<unsigned> timestamps_, Args... args_)
-        : RouteParameters{std::forward<Args>(args_)...}, timestamps{std::move(timestamps_)}
+    MatchParameters(std::vector<unsigned> timestamps_, GapsType gaps_, bool tidy_, Args... args_)
+        : RouteParameters{std::forward<Args>(args_)...}, timestamps{std::move(timestamps_)},
+          gaps(gaps_), tidy(tidy_)
    {
    }

    std::vector<unsigned> timestamps;
+    GapsType gaps;
+    bool tidy;
+
    bool IsValid() const
    {
        return RouteParameters::IsValid() &&
@@ -0,0 +1,170 @@
+#ifndef COORDINATE_TIDY
+#define COORDINATE_TIDY
+
+#include <algorithm>
+#include <cstdint>
+#include <iterator>
+
+#include "engine/api/match_parameters.hpp"
+#include "util/coordinate_calculation.hpp"
+
+#include <boost/assert.hpp>
+#include <boost/dynamic_bitset.hpp>
+
+namespace osrm
+{
+namespace engine
+{
+namespace api
+{
+namespace tidy
+{
+
+struct Thresholds
+{
+    double distance_in_meters;
+    std::int32_t duration_in_seconds;
+};
+
+using Mask = boost::dynamic_bitset<>;
+using Mapping = std::vector<std::size_t>;
+
+struct Result
+{
+    // Tidied parameters
+    MatchParameters parameters;
+    // Masking the MatchParameter parallel arrays for items which should be removed.
+    Mask can_be_removed;
+    // Maps the MatchParameter's original items to items which should not be removed.
+    Mapping tidied_to_original;
+};
+
+inline Result keep_all(const MatchParameters &params)
+{
+    Result result;
+
+    result.can_be_removed.resize(params.coordinates.size(), false);
+    result.tidied_to_original.reserve(params.coordinates.size());
+    for (std::size_t current = 0; current < params.coordinates.size(); ++current)
+    {
+        result.tidied_to_original.push_back(current);
+    }
+
+    BOOST_ASSERT(result.can_be_removed.size() == params.coordinates.size());
+
+    // We have to filter parallel arrays that may be empty or the exact same size.
+    // result.parameters contains an empty MatchParameters at this point: conditionally fill.
+
+    for (std::size_t i = 0; i < result.can_be_removed.size(); ++i)
+    {
+        if (!result.can_be_removed[i])
+        {
+            result.parameters.coordinates.push_back(params.coordinates[i]);
+
+            if (!params.hints.empty())
+                result.parameters.hints.push_back(params.hints[i]);
+
+            if (!params.radiuses.empty())
+                result.parameters.radiuses.push_back(params.radiuses[i]);
+
+            if (!params.bearings.empty())
+                result.parameters.bearings.push_back(params.bearings[i]);
+
+            if (!params.timestamps.empty())
+                result.parameters.timestamps.push_back(params.timestamps[i]);
+        }
+    }
+
+    return result;
+}
+
+inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
+{
+    Result result;
+
+    result.can_be_removed.resize(params.coordinates.size(), false);
+
+    result.tidied_to_original.push_back(0);
+    std::size_t last_good = 0;
+
+    const auto uses_timestamps = !params.timestamps.empty();
+
+    Thresholds running{0., 0};
+
+    // Walk over adjacent (coord, ts)-pairs, with rhs being the candidate to discard or keep
+    for (std::size_t current = 0; current < params.coordinates.size() - 1; ++current)
+    {
+        const auto next = current + 1;
+
+        auto distance_delta = util::coordinate_calculation::haversineDistance(
+            params.coordinates[current], params.coordinates[next]);
+        running.distance_in_meters += distance_delta;
+        const auto over_distance = running.distance_in_meters >= cfg.distance_in_meters;
+
+        if (uses_timestamps)
+        {
+            auto duration_delta = params.timestamps[next] - params.timestamps[current];
+            running.duration_in_seconds += duration_delta;
+            const auto over_duration = running.duration_in_seconds >= cfg.duration_in_seconds;
+
+            if (over_distance && over_duration)
+            {
+                last_good = next;
+                result.tidied_to_original.push_back(next);
+                running = {0., 0}; // reset running distance and time
+            }
+            else
+            {
+                result.can_be_removed.set(next, true);
+            }
+        }
+        else
+        {
+            if (over_distance)
+            {
+                last_good = next;
+                result.tidied_to_original.push_back(next);
+                running = {0., 0}; // reset running distance and time
+            }
+            else
+            {
+                result.can_be_removed.set(next, true);
+            }
+        }
+    }
+
+    BOOST_ASSERT(result.can_be_removed.size() == params.coordinates.size());
+
+    // We have to filter parallel arrays that may be empty or the exact same size.
+    // result.parameters contains an empty MatchParameters at this point: conditionally fill.
+
+    for (std::size_t i = 0; i < result.can_be_removed.size(); ++i)
+    {
+        if (!result.can_be_removed[i])
+        {
+            result.parameters.coordinates.push_back(params.coordinates[i]);
+
+            if (!params.hints.empty())
+                result.parameters.hints.push_back(params.hints[i]);
+
+            if (!params.radiuses.empty())
+                result.parameters.radiuses.push_back(params.radiuses[i]);
+
+            if (!params.bearings.empty())
+                result.parameters.bearings.push_back(params.bearings[i]);
+
+            if (!params.timestamps.empty())
+                result.parameters.timestamps.push_back(params.timestamps[i]);
+        }
+    }
+    BOOST_ASSERT(result.tidied_to_original.size() == result.parameters.coordinates.size());
+
+    return result;
+}
+
+} // ns tidy
+} // ns api
+} // ns engine
+} // ns osrm
+
+#endif
@@ -38,7 +38,8 @@ class RoutingAlgorithmsInterface
    MapMatching(const routing_algorithms::CandidateLists &candidates_list,
                const std::vector<util::Coordinate> &trace_coordinates,
                const std::vector<unsigned> &trace_timestamps,
-                const std::vector<boost::optional<double>> &trace_gps_precision) const = 0;
+                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const bool allow_splitting) const = 0;

    virtual std::vector<routing_algorithms::TurnData>
    GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
@@ -79,11 +80,12 @@ template <typename AlgorithmT> class RoutingAlgorithms final : public RoutingAlg
                     const std::vector<std::size_t> &source_indices,
                     const std::vector<std::size_t> &target_indices) const final override;

-    routing_algorithms::SubMatchingList MapMatching(
-        const routing_algorithms::CandidateLists &candidates_list,
-        const std::vector<util::Coordinate> &trace_coordinates,
-        const std::vector<unsigned> &trace_timestamps,
-        const std::vector<boost::optional<double>> &trace_gps_precision) const final override;
+    routing_algorithms::SubMatchingList
+    MapMatching(const routing_algorithms::CandidateLists &candidates_list,
+                const std::vector<util::Coordinate> &trace_coordinates,
+                const std::vector<unsigned> &trace_timestamps,
+                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const bool allow_splitting) const final override;

    std::vector<routing_algorithms::TurnData>
    GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
@@ -163,10 +165,16 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<AlgorithmT>::MapMat
    const routing_algorithms::CandidateLists &candidates_list,
    const std::vector<util::Coordinate> &trace_coordinates,
    const std::vector<unsigned> &trace_timestamps,
-    const std::vector<boost::optional<double>> &trace_gps_precision) const
+    const std::vector<boost::optional<double>> &trace_gps_precision,
+    const bool allow_splitting) const
 {
-    return routing_algorithms::mapMatching(
-        heaps, facade, candidates_list, trace_coordinates, trace_timestamps, trace_gps_precision);
+    return routing_algorithms::mapMatching(heaps,
+                                           facade,
+                                           candidates_list,
+                                           trace_coordinates,
+                                           trace_timestamps,
+                                           trace_gps_precision,
+                                           allow_splitting);
 }

 template <typename AlgorithmT>
@@ -207,7 +215,8 @@ inline routing_algorithms::SubMatchingList
 RoutingAlgorithms<algorithm::MLD>::MapMatching(const routing_algorithms::CandidateLists &,
                                               const std::vector<util::Coordinate> &,
                                               const std::vector<unsigned> &,
-                                               const std::vector<boost::optional<double>> &) const
+                                               const std::vector<boost::optional<double>> &,
+                                               const bool) const
 {
    throw util::exception("MapMatching is not implemented");
 }
@@ -28,7 +28,8 @@ mapMatching(SearchEngineData &engine_working_data,
            const CandidateLists &candidates_list,
            const std::vector<util::Coordinate> &trace_coordinates,
            const std::vector<unsigned> &trace_timestamps,
-            const std::vector<boost::optional<double>> &trace_gps_precision);
+            const std::vector<boost::optional<double>> &trace_gps_precision,
+            const bool allow_splitting);

 SubMatchingList
 mapMatching(SearchEngineData &engine_working_data,
@@ -36,7 +37,8 @@ mapMatching(SearchEngineData &engine_working_data,
            const CandidateLists &candidates_list,
            const std::vector<util::Coordinate> &trace_coordinates,
            const std::vector<unsigned> &trace_timestamps,
-            const std::vector<boost::optional<double>> &trace_gps_precision);
+            const std::vector<boost::optional<double>> &trace_gps_precision,
+            const bool allow_splitting);
 }
 }
 }
@@ -62,13 +62,6 @@ struct ExtractionWay
        forward_restricted = false;
    }

-    // These accessors exists because it's not possible to take the address of a bitfield,
-    // and LUA therefore cannot read/write the mode attributes directly.
-    void set_forward_mode(const TravelMode m) { forward_travel_mode = m; }
-    TravelMode get_forward_mode() const { return forward_travel_mode; }
-    void set_backward_mode(const TravelMode m) { backward_travel_mode = m; }
-    TravelMode get_backward_mode() const { return backward_travel_mode; }
-
    // wrappers to allow assigning nil (nullptr) to string values
    void SetName(const char *value) { detail::maybeSetString(name, value); }
    const char *GetName() const { return name.c_str(); }
@@ -105,14 +98,14 @@ struct ExtractionWay
    std::string destinations;
    std::string turn_lanes_forward;
    std::string turn_lanes_backward;
-    bool roundabout;
-    bool circular;
-    bool is_startpoint;
-    bool backward_restricted;
-    bool forward_restricted;
+    guidance::RoadClassification road_classification;
    TravelMode forward_travel_mode : 4;
    TravelMode backward_travel_mode : 4;
-    guidance::RoadClassification road_classification;
+    bool roundabout : 1;
+    bool circular : 1;
+    bool is_startpoint : 1;
+    bool forward_restricted : 1;
+    bool backward_restricted : 1;
 };
 }
 }
@@ -63,6 +63,7 @@ class ExtractorCallbacks
    guidance::LaneDescriptionMap lane_description_map;
    ExtractionContainers &external_memory;
    bool fallback_to_duration;
+    bool force_split_edges;

  public:
    explicit ExtractorCallbacks(ExtractionContainers &extraction_containers,
@@ -87,6 +87,7 @@ struct ProfileProperties
    //! stores the name of the weight (e.g. 'duration', 'distance', 'safety')
    char weight_name[MAX_WEIGHT_NAME_LENGTH + 1];
    unsigned weight_precision = 1;
+    bool force_split_edges = false;
 };
 }
 }
@@ -112,11 +112,18 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
    auto params = Nan::To<v8::Object>(args[0]).ToLocalChecked();

    auto path = params->Get(Nan::New("path").ToLocalChecked());
+    if (path.IsEmpty())
+        return engine_config_ptr();
+
    auto shared_memory = params->Get(Nan::New("shared_memory").ToLocalChecked());
+    if (shared_memory.IsEmpty())
+        return engine_config_ptr();
+
    if (!path->IsUndefined())
    {
        engine_config->storage_config =
            osrm::StorageConfig(*v8::String::Utf8Value(Nan::To<v8::String>(path).ToLocalChecked()));
+        engine_config->use_shared_memory = false;
    }
    if (!shared_memory->IsUndefined())
    {
@@ -138,6 +145,37 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
        return engine_config_ptr();
    }

+    auto algorithm = params->Get(Nan::New("algorithm").ToLocalChecked());
+    if (algorithm.IsEmpty())
+        return engine_config_ptr();
+
+    if (algorithm->IsString())
+    {
+        auto algorithm_str = Nan::To<v8::String>(algorithm).ToLocalChecked();
+        if (*v8::String::Utf8Value(algorithm_str) == std::string("CH"))
+        {
+            engine_config->algorithm = osrm::EngineConfig::Algorithm::CH;
+        }
+        else if (*v8::String::Utf8Value(algorithm_str) == std::string("CoreCH"))
+        {
+            engine_config->algorithm = osrm::EngineConfig::Algorithm::CoreCH;
+        }
+        else if (*v8::String::Utf8Value(algorithm_str) == std::string("MLD"))
+        {
+            engine_config->algorithm = osrm::EngineConfig::Algorithm::MLD;
+        }
+        else
+        {
+            Nan::ThrowError("algorithm option must be one of 'CH', 'CoreCH', or 'MLD'.");
+            return engine_config_ptr();
+        }
+    }
+    else if (!algorithm->IsUndefined())
+    {
+        Nan::ThrowError("algorithm option must be a string and one of 'CH', 'CoreCH', or 'MLD'.");
+        return engine_config_ptr();
+    }
+
    return engine_config;
 }

@@ -151,6 +189,8 @@ parseCoordinateArray(const v8::Local<v8::Array> &coordinates_array)
    for (uint32_t i = 0; i < coordinates_array->Length(); ++i)
    {
        v8::Local<v8::Value> coordinate = coordinates_array->Get(i);
+        if (coordinate.IsEmpty())
+            return resulting_coordinates;

        if (!coordinate->IsArray())
        {
@@ -218,6 +258,9 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();

    v8::Local<v8::Value> coordinates = obj->Get(Nan::New("coordinates").ToLocalChecked());
+    if (coordinates.IsEmpty())
+        return false;
+
    if (coordinates->IsUndefined())
    {
        Nan::ThrowError("Must provide a coordinates property");
@@ -258,6 +301,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    if (obj->Has(Nan::New("bearings").ToLocalChecked()))
    {
        v8::Local<v8::Value> bearings = obj->Get(Nan::New("bearings").ToLocalChecked());
+        if (bearings.IsEmpty())
+            return false;

        if (!bearings->IsArray())
        {
@@ -276,6 +321,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
        for (uint32_t i = 0; i < bearings_array->Length(); ++i)
        {
            v8::Local<v8::Value> bearing_raw = bearings_array->Get(i);
+            if (bearing_raw.IsEmpty())
+                return false;

            if (bearing_raw->IsNull())
            {
@@ -320,6 +367,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    if (obj->Has(Nan::New("hints").ToLocalChecked()))
    {
        v8::Local<v8::Value> hints = obj->Get(Nan::New("hints").ToLocalChecked());
+        if (hints.IsEmpty())
+            return false;

        if (!hints->IsArray())
        {
@@ -338,6 +387,9 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
        for (uint32_t i = 0; i < hints_array->Length(); ++i)
        {
            v8::Local<v8::Value> hint = hints_array->Get(i);
+            if (hint.IsEmpty())
+                return false;
+
            if (hint->IsString())
            {
                if (hint->ToString()->Length() == 0)
@@ -364,6 +416,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    if (obj->Has(Nan::New("radiuses").ToLocalChecked()))
    {
        v8::Local<v8::Value> radiuses = obj->Get(Nan::New("radiuses").ToLocalChecked());
+        if (radiuses.IsEmpty())
+            return false;

        if (!radiuses->IsArray())
        {
@@ -382,6 +436,9 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
        for (uint32_t i = 0; i < radiuses_array->Length(); ++i)
        {
            v8::Local<v8::Value> radius = radiuses_array->Get(i);
+            if (radius.IsEmpty())
+                return false;
+
            if (radius->IsNull())
            {
                params->radiuses.emplace_back();
@@ -401,6 +458,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    if (obj->Has(Nan::New("generate_hints").ToLocalChecked()))
    {
        v8::Local<v8::Value> generate_hints = obj->Get(Nan::New("generate_hints").ToLocalChecked());
+        if (generate_hints.IsEmpty())
+            return false;

        if (!generate_hints->IsBoolean())
        {
@@ -420,6 +479,9 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
    if (obj->Has(Nan::New("steps").ToLocalChecked()))
    {
        auto steps = obj->Get(Nan::New("steps").ToLocalChecked());
+        if (steps.IsEmpty())
+            return false;
+
        if (steps->IsBoolean())
        {
            params->steps = steps->BooleanValue();
@@ -434,6 +496,9 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
    if (obj->Has(Nan::New("annotations").ToLocalChecked()))
    {
        auto annotations = obj->Get(Nan::New("annotations").ToLocalChecked());
+        if (annotations.IsEmpty())
+            return false;
+
        if (annotations->IsBoolean())
        {
            params->annotations = annotations->BooleanValue();
@@ -494,6 +559,8 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
    if (obj->Has(Nan::New("geometries").ToLocalChecked()))
    {
        v8::Local<v8::Value> geometries = obj->Get(Nan::New("geometries").ToLocalChecked());
+        if (geometries.IsEmpty())
+            return false;

        if (!geometries->IsString())
        {
@@ -526,6 +593,8 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
    if (obj->Has(Nan::New("overview").ToLocalChecked()))
    {
        v8::Local<v8::Value> overview = obj->Get(Nan::New("overview").ToLocalChecked());
+        if (overview.IsEmpty())
+            return false;

        if (!overview->IsString())
        {
@@ -572,9 +641,13 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("continue_straight").ToLocalChecked()))
    {
        auto value = obj->Get(Nan::New("continue_straight").ToLocalChecked());
+        if (value.IsEmpty())
+            return route_parameters_ptr();
+
        if (!value->IsBoolean() && !value->IsNull())
        {
            Nan::ThrowError("'continue_straight' parama must be boolean or null");
+            return route_parameters_ptr();
        }
        if (value->IsBoolean())
        {
@@ -585,9 +658,13 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("alternatives").ToLocalChecked()))
    {
        auto value = obj->Get(Nan::New("alternatives").ToLocalChecked());
+        if (value.IsEmpty())
+            return route_parameters_ptr();
+
        if (!value->IsBoolean())
        {
            Nan::ThrowError("'alternatives' parama must be boolean");
+            return route_parameters_ptr();
        }
        params->alternatives = value->BooleanValue();
    }
@@ -629,6 +706,8 @@ argumentsToTileParameters(const Nan::FunctionCallbackInfo<v8::Value> &args, bool
    v8::Local<v8::Value> x = array->Get(0);
    v8::Local<v8::Value> y = array->Get(1);
    v8::Local<v8::Value> z = array->Get(2);
+    if (x.IsEmpty() || y.IsEmpty() || z.IsEmpty())
+        return tile_parameters_ptr();

    if (!x->IsUint32() && !x->IsUndefined())
    {
@@ -669,6 +748,8 @@ argumentsToNearestParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        return nearest_parameters_ptr();

    v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();
+    if (obj.IsEmpty())
+        return nearest_parameters_ptr();

    if (obj->Has(Nan::New("number").ToLocalChecked()))
    {
@@ -706,10 +787,14 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        return table_parameters_ptr();

    v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();
+    if (obj.IsEmpty())
+        return table_parameters_ptr();

    if (obj->Has(Nan::New("sources").ToLocalChecked()))
    {
        v8::Local<v8::Value> sources = obj->Get(Nan::New("sources").ToLocalChecked());
+        if (sources.IsEmpty())
+            return table_parameters_ptr();

        if (!sources->IsArray())
        {
@@ -721,6 +806,9 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        for (uint32_t i = 0; i < sources_array->Length(); ++i)
        {
            v8::Local<v8::Value> source = sources_array->Get(i);
+            if (source.IsEmpty())
+                return table_parameters_ptr();
+
            if (source->IsUint32())
            {
                size_t source_value = static_cast<size_t>(source->NumberValue());
@@ -744,6 +832,8 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("destinations").ToLocalChecked()))
    {
        v8::Local<v8::Value> destinations = obj->Get(Nan::New("destinations").ToLocalChecked());
+        if (destinations.IsEmpty())
+            return table_parameters_ptr();

        if (!destinations->IsArray())
        {
@@ -755,6 +845,9 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        for (uint32_t i = 0; i < destinations_array->Length(); ++i)
        {
            v8::Local<v8::Value> destination = destinations_array->Get(i);
+            if (destination.IsEmpty())
+                return table_parameters_ptr();
+
            if (destination->IsUint32())
            {
                size_t destination_value = static_cast<size_t>(destination->NumberValue());
@@ -798,6 +891,9 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("roundtrip").ToLocalChecked()))
    {
        auto roundtrip = obj->Get(Nan::New("roundtrip").ToLocalChecked());
+        if (roundtrip.IsEmpty())
+            return trip_parameters_ptr();
+
        if (roundtrip->IsBoolean())
        {
            params->roundtrip = roundtrip->BooleanValue();
@@ -812,6 +908,8 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("source").ToLocalChecked()))
    {
        v8::Local<v8::Value> source = obj->Get(Nan::New("source").ToLocalChecked());
+        if (source.IsEmpty())
+            return trip_parameters_ptr();

        if (!source->IsString())
        {
@@ -839,6 +937,8 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("destination").ToLocalChecked()))
    {
        v8::Local<v8::Value> destination = obj->Get(Nan::New("destination").ToLocalChecked());
+        if (destination.IsEmpty())
+            return trip_parameters_ptr();

        if (!destination->IsString())
        {
@@ -880,6 +980,8 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("timestamps").ToLocalChecked()))
    {
        v8::Local<v8::Value> timestamps = obj->Get(Nan::New("timestamps").ToLocalChecked());
+        if (timestamps.IsEmpty())
+            return match_parameters_ptr();

        if (!timestamps->IsArray())
        {
@@ -899,6 +1001,9 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        for (uint32_t i = 0; i < timestamps_array->Length(); ++i)
        {
            v8::Local<v8::Value> timestamp = timestamps_array->Get(i);
+            if (timestamp.IsEmpty())
+                return match_parameters_ptr();
+
            if (!timestamp->IsNumber())
            {
                Nan::ThrowError("Timestamps array items must be numbers");
@@ -110,9 +110,17 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, UseSharedMemory>
        // which can be smaller then the total number of nodes.
        // this will save memory in case we sort the border nodes first
        if (index >= node_to_edge_offset.size() - 1)
-            return SuperT::BeginEdges(node);
+        {
+            // On level 0 all edges are border edges
+            if (level == 0)
+                return SuperT::BeginEdges(node);
+            else
+                return SuperT::EndEdges(node);
+        }
        else
+        {
            return SuperT::BeginEdges(node) + node_to_edge_offset[index + level];
+        }
    }

    // We save the level as sentinel at the end
@@ -13,7 +13,12 @@ namespace partition

 struct PartitionConfig
 {
-    PartitionConfig() : requested_num_threads(0) {}
+    PartitionConfig()
+        : requested_num_threads(0), balance(1.2), boundary_factor(0.25), num_optimizing_cuts(10),
+          small_component_size(1000),
+          max_cell_sizes{128, 128 * 32, 128 * 32 * 16, 128 * 32 * 16 * 32}
+    {
+    }

    void UseDefaults()
    {
@@ -49,11 +54,11 @@ struct PartitionConfig

    unsigned requested_num_threads;

-    std::size_t minimum_cell_size;
    double balance;
    double boundary_factor;
    std::size_t num_optimizing_cuts;
    std::size_t small_component_size;
+    std::vector<std::size_t> max_cell_sizes;
 };
 }
 }
@@ -33,13 +33,24 @@ struct MatchParametersGrammar final : public RouteParametersGrammar<Iterator, Si
            (qi::uint_ %
             ';')[ph::bind(&engine::api::MatchParameters::timestamps, qi::_r1) = qi::_1];

-        root_rule = BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
-                    -('?' > (timestamps_rule(qi::_r1) | BaseGrammar::base_rule(qi::_r1)) % '&');
+        gaps_type.add("split", engine::api::MatchParameters::GapsType::Split)(
+            "ignore", engine::api::MatchParameters::GapsType::Ignore);
+
+        root_rule =
+            BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
+            -('?' > (timestamps_rule(qi::_r1) | BaseGrammar::base_rule(qi::_r1) |
+                     (qi::lit("gaps=") >
+                      gaps_type[ph::bind(&engine::api::MatchParameters::gaps, qi::_r1) = qi::_1]) |
+                     (qi::lit("tidy=") >
+                      qi::bool_[ph::bind(&engine::api::MatchParameters::tidy, qi::_r1) = qi::_1])) %
+                        '&');
    }

  private:
    qi::rule<Iterator, Signature> root_rule;
    qi::rule<Iterator, Signature> timestamps_rule;
+
+    qi::symbols<char, engine::api::MatchParameters::GapsType> gaps_type;
 };
 }
 }
@@ -151,7 +151,7 @@ class SharedMemory
 #else
    void WaitForDetach()
    {
-        util::Log(logWARNING)
+        util::Log(logDEBUG)
            << "Shared memory support for non-Linux systems does not wait for clients to "
               "dettach. Going to sleep for 50ms.";
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
@@ -245,8 +245,8 @@ class SharedMemory
    void WaitForDetach()
    {
        // FIXME this needs an implementation for Windows
-        util::Log(logWARNING) << "Shared memory support for Windows does not wait for clients to "
-                                 "dettach. Going to sleep for 50ms.";
+        util::Log(logDEBUG) << "Shared memory support for Windows does not wait for clients to "
+                               "dettach. Going to sleep for 50ms.";
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }

@@ -1,25 +1,12 @@
 {
  "name": "osrm",
-  "version": "5.7.0",
-  "private": true,
+  "version": "5.7.0-latest.2",
+  "private": false,
  "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
  "dependencies": {
-    "chalk": "^1.1.3",
-    "cucumber": "^1.2.1",
-    "d3-queue": "^2.0.3",
-    "mkdirp": "^0.5.1",
-    "node-timeout": "0.0.4",
-    "polyline": "^0.2.0",
-    "request": "^2.69.0",
-    "rimraf": "^2.5.4",
-    "xmlbuilder": "^4.2.1",
-
    "nan": "^2.1.0",
    "node-cmake": "^1.2.1",
-    "node-pre-gyp": "~0.6.30"
-  },
-  "bin": {
-    "cucumber": "./node_modules/cucumber/bin/cucumber.js"
+    "node-pre-gyp": "^0.6.34"
  },
  "browserify": {
    "transform": [
@@ -30,19 +17,16 @@
  "scripts": {
    "lint": "eslint -c ./.eslintrc features/step_definitions/ features/support/",
    "test": "npm run lint && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify && node ./node_modules/cucumber/bin/cucumber.js features/ -p mld",
-    "clean-test": "rm -rf test/cache",
-    "cucumber": "./node_modules/cucumber/bin/cucumber.js",
-    "build-api-docs": "./scripts/build_api_docs.sh",
-
-    "preinstall": "npm install node-pre-gyp",
+    "clean": "rm -rf test/cache",
+    "docs": "./scripts/build_api_docs.sh",
    "install": "node-pre-gyp install --fallback-to-build=false"
  },
  "repository": {
    "type": "git",
    "url": "https://github.com/Project-OSRM/osrm-backend.git"
  },
-  "author": "",
-  "license": "ISC",
+  "author": "Project OSRM Team",
+  "license": "BSD 2-Clause",
  "bugs": {
    "url": "https://github.com/Project-OSRM/osrm-backend/issues"
  },
@@ -51,12 +35,24 @@
    "node": ">=4.0.0"
  },
  "devDependencies": {
-    "docbox": "^1.0.2",
+    "docbox": "^1.0.5",
+    "documentation": "^4.0.0-beta.18",
    "eslint": "^2.4.0",
-
+    "chalk": "^1.1.3",
+    "cucumber": "^1.2.1",
+    "d3-queue": "^2.0.3",
+    "mkdirp": "^0.5.1",
    "aws-sdk": "~2.0.31",
-    "tape": "^4.2.2"
+    "tape": "^4.2.2",
+    "node-timeout": "0.0.4",
+    "polyline": "^0.2.0",
+    "request": "^2.69.0",
+    "rimraf": "^2.5.4",
+    "xmlbuilder": "^4.2.1"
  },
+  "bundleDependencies": [
+    "node-pre-gyp"
+  ],
  "main": "lib/index.js",
  "binary": {
    "module_name": "node-osrm",
@@ -444,17 +444,29 @@ function way_function (way, result)
  end

  -- cycleways
+  local has_cycleway_left, has_cycleway_right
  if cycleway and profile.cycleway_tags[cycleway] then
-    result.forward_speed = profile.bicycle_speeds["cycleway"]
-    result.backward_speed = profile.bicycle_speeds["cycleway"]
+    has_cycleway_left = true
+    has_cycleway_right = true
  elseif cycleway_left and profile.cycleway_tags[cycleway_left] then
-    result.forward_speed = profile.bicycle_speeds["cycleway"]
-    result.backward_speed = profile.bicycle_speeds["cycleway"]
+    has_cycleway_left = true
+    has_cycleway_right = true
  elseif cycleway_right and profile.cycleway_tags[cycleway_right] then
+    has_cycleway_left = true
+    has_cycleway_right = true
+  end
+  if has_cycleway_right and
+     (result.forward_mode == mode.inaccessible or
+      result.forward_mode == mode.cycling) then
    result.forward_speed = profile.bicycle_speeds["cycleway"]
+  end
+  if has_cycleway_left and
+     (result.backward_mode == mode.inaccessible or
+      result.backward_mode == mode.cycling) then
    result.backward_speed = profile.bicycle_speeds["cycleway"]
  end

+
  -- dismount
  if bicycle == "dismount" then
    result.forward_mode = mode.pushing_bike
@@ -33,6 +33,7 @@ local profile = {
    'sally_port',
    'gate',
    'no',
+    'kerb',
    'block'
  },

@@ -1,6 +1,8 @@
 api_version = 1
 -- Rasterbot profile

+properties.force_split_edges = true
+
 -- Minimalist node_ and way_functions in order to test source_ and segment_functions

 function node_function (node, result)
@@ -46,7 +48,7 @@ function segment_function (segment)
  local scaled_duration = segment.duration

  if sourceData.datum ~= invalid and targetData.datum ~= invalid then
-    local slope = math.abs(sourceData.datum - targetData.datum) / segment.distance
+    local slope = (targetData.datum - sourceData.datum) / segment.distance
    scaled_weight = scaled_weight / (1.0 - (slope * 5.0))
    scaled_duration = scaled_duration / (1.0 - (slope * 5.0))
    io.write("   slope: " .. slope .. "\n")
@@ -14,6 +14,8 @@ babel -V >/dev/null 2>&1 || { echo >&2 "Can't find babel.  Add node_modules/.bin
 browserify --help >/dev/null 2>&1 || { echo >&2 "Can't find browserify.  Add node_modules/.bin to your path, or run via \"npm run\""; exit 1; }
 uglifyjs -V >/dev/null 2>&1 || { echo >&2 "Can't find uglifyjs.  Add node_modules/.bin to your path, or run via \"npm run\""; exit 1; }

+#documentation build src/nodejs/node_osrm.cpp --polyglot -f md -o docs/nodejs/api.md
+
 # Clean up previous version
 rm -rf build/docs

@@ -1,99 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-set -o pipefail
-
-# defaults
-export ENABLE_COVERAGE=${ENABLE_COVERAGE:-"Off"}
-export BUILD_TYPE=${BUILD_TYPE:-"Release"}
-export NODE=${NODE:-4}
-
-export CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-export DEPS_DIR="$(pwd)/deps"
-export PATH=${DEPS_DIR}/bin:${PATH}
-mkdir -p ${DEPS_DIR}
-
-export CLANG_VERSION="${CLANG_VERSION:-4.0.0}"
-export CCACHE_VERSION=3.3.1
-export CMAKE_VERSION=3.7.2
-
-source ${CURRENT_DIR}/travis_helper.sh
-
-# ensure we start inside the root directory (two level up)
-cd ${CURRENT_DIR}/../../
-
-if [[ ! $(which wget) ]]; then
-    echo "echo wget must be installed";
-    exit 1;
-fi;
-
-SYSTEM_NAME=$(uname -s)
-if [[ "${SYSTEM_NAME}" == "Darwin" ]]; then
-    OS_NAME="osx"
-elif [[ "${SYSTEM_NAME}" == "Linux" ]]; then
-    OS_NAME="linux"
-fi
-
-# FIXME This should be replaced by proper calls to mason but we currently have a chicken-egg problem
-# since we rely on osrm-backend to ship mason for us. Once we merged this into osrm-backend this will not be needed.
-CMAKE_URL="https://s3.amazonaws.com/mason-binaries/${OS_NAME}-x86_64/cmake/${CMAKE_VERSION}.tar.gz"
-echo "Downloading cmake from ${CMAKE_URL} ..."
-wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C ${DEPS_DIR} || exit 1
-CCACHE_URL="https://s3.amazonaws.com/mason-binaries/${OS_NAME}-x86_64/ccache/${CCACHE_VERSION}.tar.gz"
-echo "Downloading ccache from ${CCACHE_URL} ..."
-wget --quiet -O - ${CCACHE_URL} | tar --strip-components=1 -xz -C ${DEPS_DIR} || exit 1
-# install clang for linux but use the xcode version on OSX
-if [[ "${OS_NAME}" != "osx" ]]; then
-    CLANG_URL="https://s3.amazonaws.com/mason-binaries/${OS_NAME}-x86_64/clang++/${CLANG_VERSION}.tar.gz"
-    echo "Downloading clang from ${CLANG_URL} ..."
-    wget --quiet -O - ${CLANG_URL} | tar --strip-components=1 -xz -C ${DEPS_DIR} || exit 1
-    export CCOMPILER='clang'
-    export CXXCOMPILER='clang++'
-    export CC='clang'
-    export CXX='clang++'
-fi
-
-if [[ "${OS_NAME}" == "osx" ]]; then
-    if [[ -f /etc/sysctl.conf ]] && [[ $(grep shmmax /etc/sysctl.conf) ]]; then
-        echo "Note: found shmmax setting in /etc/sysctl.conf, not modifying"
-    else
-        echo "WARNING: Did not find shmmax setting in /etc/sysctl.conf, adding now (requires sudo and restarting)..."
-        sudo sysctl -w kern.sysv.shmmax=4294967296
-        sudo sysctl -w kern.sysv.shmall=1048576
-        sudo sysctl -w kern.sysv.shmseg=128
-    fi
-fi
-
-
-echo "Now build node-osrm and dependencies"
-export VERBOSE=1
-if [[ "${ENABLE_COVERAGE}" == "On" ]]; then
-    mapbox_time "make" make -j4 coverage
-else
-    mkdir -p build
-    pushd build
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_NODE_BINDINGS=On -DENABLE_MASON=On
-    mapbox_time "make" make -j4
-    popd
-fi
-
-## run tests, with backtrace support
-#if [[ "${OS_NAME}" == "linux" ]]; then
-#    ulimit -c unlimited -S
-#    RESULT=0
-#    mapbox_time "make-test" make tests || RESULT=$?
-#    for i in $(find ./ -maxdepth 1 -name 'core*' -print);
-#      do gdb $(which node) $i -ex "thread apply all bt" -ex "set pagination 0" -batch;
-#    done;
-#    if [[ ${RESULT} != 0 ]]; then exit $RESULT; fi
-#else
-#    # todo: coredump support on OS X
-#    RESULT=0
-#    mapbox_time "make-test" make tests || RESULT=$?
-#    if [[ ${RESULT} != 0 ]]; then exit $RESULT; fi
-#fi
-
-
-set +eu
-set +o pipefail
@@ -3,49 +3,31 @@
 set -eu
 set -o pipefail

-# should be set for debug builds
-export NPM_FLAGS=${NPM_FLAGS:-}
+if [[ ${PUBLISH} == 'On' ]]; then
+    echo "PUBLISH is set to '${PUBLISH}', publishing!"

-echo "node version is:"
-which node
-node -v
+    echo "node version is:"
+    which node
+    node -v

-echo "dumping binary meta..."
-./node_modules/.bin/node-pre-gyp reveal ${NPM_FLAGS}
+    echo "dumping binary meta..."
+    ./node_modules/.bin/node-pre-gyp reveal

-# enforce that binary has proper ORIGIN flags so that
-# it can portably find libtbb.so in the same directory
-if [[ $(uname -s) == 'Linux' ]]; then
-    readelf -d ./lib/binding/node-osrm.node > readelf-output.txt
-    if grep -q 'Flags: ORIGIN' readelf-output.txt; then
-        echo "Found ORIGIN flag in readelf output"
-        cat readelf-output.txt
-    else
-        echo "*** Error: Could not found ORIGIN flag in readelf output"
-        cat readelf-output.txt
-        exit 1
+    # enforce that binary has proper ORIGIN flags so that
+    # it can portably find libtbb.so in the same directory
+    if [[ $(uname -s) == 'Linux' ]]; then
+        readelf -d ./lib/binding/node-osrm.node > readelf-output.txt
+        if grep -q 'Flags: ORIGIN' readelf-output.txt; then
+            echo "Found ORIGIN flag in readelf output"
+            cat readelf-output.txt
+        else
+            echo "*** Error: Could not found ORIGIN flag in readelf output"
+            cat readelf-output.txt
+            exit 1
+        fi
    fi
-fi

-echo "determining publishing status..."
-
-if [[ $(./scripts/travis/is_pr_merge.sh) ]]; then
-    echo "Skipping publishing because this is a PR merge commit"
+    ./node_modules/.bin/node-pre-gyp package publish info
 else
-    echo "This is a push commit, continuing to package..."
-    ./node_modules/.bin/node-pre-gyp package ${NPM_FLAGS}
-
-    export COMMIT_MESSAGE=$(git log --format=%B --no-merges | head -n 1 | tr -d '\n')
-    echo "Commit message: ${COMMIT_MESSAGE}"
-
-    if [[ ${COMMIT_MESSAGE} =~ "[publish binary]" ]]; then
-        echo "Publishing"
-        ./node_modules/.bin/node-pre-gyp publish ${NPM_FLAGS}
-    elif [[ ${COMMIT_MESSAGE} =~ "[republish binary]" ]]; then
-        echo "*** Error: Republishing is disallowed for this repository"
-        exit 1
-        #./node_modules/.bin/node-pre-gyp unpublish publish ${NPM_FLAGS}
-    else
-        echo "Skipping publishing"
-    fi;
+    echo "PUBLISH is set to '${PUBLISH}', skipping."
 fi
@@ -3,6 +3,7 @@

 #include "engine/api/match_api.hpp"
 #include "engine/api/match_parameters.hpp"
+#include "engine/api/match_parameters_tidy.hpp"
 #include "engine/map_matching/bayes_classifier.hpp"
 #include "engine/map_matching/sub_matching.hpp"
 #include "util/coordinate_calculation.hpp"
@@ -145,20 +146,33 @@ Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
            "InvalidValue", "Timestamps need to be monotonically increasing.", json_result);
    }

+    SubMatchingList sub_matchings;
+    api::tidy::Result tidied;
+    if (parameters.tidy)
+    {
+        // Transparently tidy match parameters, do map matching on tidied parameters.
+        // Then use the mapping to restore the original <-> tidied relationship.
+        tidied = api::tidy::tidy(parameters);
+    }
+    else
+    {
+        tidied = api::tidy::keep_all(parameters);
+    }
+
    // assuming radius is the standard deviation of a normal distribution
    // that models GPS noise (in this model), x3 should give us the correct
    // search radius with > 99% confidence
    std::vector<double> search_radiuses;
-    if (parameters.radiuses.empty())
+    if (tidied.parameters.radiuses.empty())
    {
-        search_radiuses.resize(parameters.coordinates.size(),
+        search_radiuses.resize(tidied.parameters.coordinates.size(),
                               routing_algorithms::DEFAULT_GPS_PRECISION * RADIUS_MULTIPLIER);
    }
    else
    {
-        search_radiuses.resize(parameters.coordinates.size());
-        std::transform(parameters.radiuses.begin(),
-                       parameters.radiuses.end(),
+        search_radiuses.resize(tidied.parameters.coordinates.size());
+        std::transform(tidied.parameters.radiuses.begin(),
+                       tidied.parameters.radiuses.end(),
                       search_radiuses.begin(),
                       [](const boost::optional<double> &maybe_radius) {
                           if (maybe_radius)
@@ -173,9 +187,9 @@ Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
                       });
    }

-    auto candidates_lists = GetPhantomNodesInRange(facade, parameters, search_radiuses);
+    auto candidates_lists = GetPhantomNodesInRange(facade, tidied.parameters, search_radiuses);

-    filterCandidates(parameters.coordinates, candidates_lists);
+    filterCandidates(tidied.parameters.coordinates, candidates_lists);
    if (std::all_of(candidates_lists.begin(),
                    candidates_lists.end(),
                    [](const std::vector<PhantomNodeWithDistance> &candidates) {
@@ -188,8 +202,12 @@ Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
    }

    // call the actual map matching
-    SubMatchingList sub_matchings = algorithms.MapMatching(
-        candidates_lists, parameters.coordinates, parameters.timestamps, parameters.radiuses);
+    sub_matchings =
+        algorithms.MapMatching(candidates_lists,
+                               tidied.parameters.coordinates,
+                               tidied.parameters.timestamps,
+                               tidied.parameters.radiuses,
+                               parameters.gaps == api::MatchParameters::GapsType::Split);

    if (sub_matchings.size() == 0)
    {
@@ -220,7 +238,7 @@ Status MatchPlugin::HandleRequest(const datafacade::ContiguousInternalMemoryData
        BOOST_ASSERT(sub_routes[index].shortest_path_length != INVALID_EDGE_WEIGHT);
    }

-    api::MatchAPI match_api{facade, parameters};
+    api::MatchAPI match_api{facade, parameters, tidied};
    match_api.MakeResponse(sub_matchings, sub_routes, json_result);

    return Status::Ok;
@@ -54,7 +54,8 @@ mapMatchingImpl(SearchEngineData &engine_working_data,
                const CandidateLists &candidates_list,
                const std::vector<util::Coordinate> &trace_coordinates,
                const std::vector<unsigned> &trace_timestamps,
-                const std::vector<boost::optional<double>> &trace_gps_precision)
+                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const bool allow_splitting)
 {
    map_matching::MatchingConfidence confidence;
    map_matching::EmissionLogProbability default_emission_log_probability(DEFAULT_GPS_PRECISION);
@@ -156,16 +157,24 @@ mapMatchingImpl(SearchEngineData &engine_working_data,
    for (auto t = initial_timestamp + 1; t < candidates_list.size(); ++t)
    {

-        const bool gap_in_trace = [&, use_timestamps]() {
-            // use temporal information if available to determine a split
-            if (use_timestamps)
+        const bool gap_in_trace = [&]() {
+            // do not determine split if wasn't asked about it
+            if (allow_splitting)
            {
-                return trace_timestamps[t] - trace_timestamps[prev_unbroken_timestamps.back()] >
-                       max_broken_time;
+                // use temporal information if available to determine a split
+                if (use_timestamps)
+                {
+                    return trace_timestamps[t] - trace_timestamps[prev_unbroken_timestamps.back()] >
+                           max_broken_time;
+                }
+                else
+                {
+                    return t - prev_unbroken_timestamps.back() > MAX_BROKEN_STATES;
+                }
            }
            else
            {
-                return t - prev_unbroken_timestamps.back() > MAX_BROKEN_STATES;
+                return false;
            }
        }();

@@ -416,14 +425,16 @@ mapMatching(SearchEngineData &engine_working_data,
            const CandidateLists &candidates_list,
            const std::vector<util::Coordinate> &trace_coordinates,
            const std::vector<unsigned> &trace_timestamps,
-            const std::vector<boost::optional<double>> &trace_gps_precision)
+            const std::vector<boost::optional<double>> &trace_gps_precision,
+            const bool use_tidying)
 {
    return mapMatchingImpl(engine_working_data,
                           facade,
                           candidates_list,
                           trace_coordinates,
                           trace_timestamps,
-                           trace_gps_precision);
+                           trace_gps_precision,
+                           use_tidying);
 }

 SubMatchingList
@@ -432,7 +443,8 @@ mapMatching(SearchEngineData &engine_working_data,
            const CandidateLists &candidates_list,
            const std::vector<util::Coordinate> &trace_coordinates,
            const std::vector<unsigned> &trace_timestamps,
-            const std::vector<boost::optional<double>> &trace_gps_precision)
+            const std::vector<boost::optional<double>> &trace_gps_precision,
+            const bool use_tidying)
 {

    return mapMatchingImpl(engine_working_data,
@@ -440,7 +452,8 @@ mapMatching(SearchEngineData &engine_working_data,
                           candidates_list,
                           trace_coordinates,
                           trace_timestamps,
-                           trace_gps_precision);
+                           trace_gps_precision,
+                           use_tidying);
 }

 } // namespace routing_algorithms
@@ -388,21 +388,24 @@ void ExtractionContainers::PrepareEdges(ScriptingEnvironment &scripting_environm
            BOOST_ASSERT(edge_iterator->source_coordinate.lon !=
                         util::FixedLongitude{std::numeric_limits<std::int32_t>::min()});

-            const util::Coordinate target_coord{node_iterator->lon, node_iterator->lat};
-            const double distance = util::coordinate_calculation::greatCircleDistance(
-                edge_iterator->source_coordinate, target_coord);
+            util::Coordinate source_coord(edge_iterator->source_coordinate);
+            util::Coordinate target_coord{node_iterator->lon, node_iterator->lat};

-            auto weight = edge_iterator->weight_data(distance);
-            auto duration = edge_iterator->duration_data(distance);
+            // flip source and target coordinates if segment is in backward direction only
+            if (!edge_iterator->result.forward && edge_iterator->result.backward)
+                std::swap(source_coord, target_coord);

-            ExtractionSegment extracted_segment(
-                edge_iterator->source_coordinate, target_coord, distance, weight, duration);
-            scripting_environment.ProcessSegment(extracted_segment);
+            const auto distance =
+                util::coordinate_calculation::greatCircleDistance(source_coord, target_coord);
+            const auto weight = edge_iterator->weight_data(distance);
+            const auto duration = edge_iterator->duration_data(distance);
+
+            ExtractionSegment segment(source_coord, target_coord, distance, weight, duration);
+            scripting_environment.ProcessSegment(segment);

            auto &edge = edge_iterator->result;
-            edge.weight =
-                std::max<EdgeWeight>(1, std::round(extracted_segment.weight * weight_multiplier));
-            edge.duration = std::max<EdgeWeight>(1, std::round(extracted_segment.duration * 10.));
+            edge.weight = std::max<EdgeWeight>(1, std::round(segment.weight * weight_multiplier));
+            edge.duration = std::max<EdgeWeight>(1, std::round(segment.duration * 10.));

            // assign new node id
            auto id_iter = external_to_internal_node_id_map.find(node_iterator->node_id);
@@ -35,7 +35,9 @@ namespace TurnLaneType = guidance::TurnLaneType;

 ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers &extraction_containers_,
                                       const ProfileProperties &properties)
-    : external_memory(extraction_containers_), fallback_to_duration(properties.fallback_to_duration)
+    : external_memory(extraction_containers_),
+      fallback_to_duration(properties.fallback_to_duration),
+      force_split_edges(properties.force_split_edges)
 {
    // we reserved 0, 1, 2, 3 for the empty case
    string_map[MapKey("", "", "", "")] = 0;
@@ -323,14 +325,15 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
        (parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);

    // split an edge into two edges if forwards/backwards behavior differ
-    const bool split_edge = in_forward_direction && in_backward_direction &&
-                            ((parsed_way.forward_rate != parsed_way.backward_rate) ||
-                             (parsed_way.forward_speed != parsed_way.backward_speed) ||
-                             (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode) ||
-                             (turn_lane_id_forward != turn_lane_id_backward));
+    const bool split_edge =
+        in_forward_direction && in_backward_direction &&
+        (force_split_edges || (parsed_way.forward_rate != parsed_way.backward_rate) ||
+         (parsed_way.forward_speed != parsed_way.backward_speed) ||
+         (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode) ||
+         (turn_lane_id_forward != turn_lane_id_backward));

    if (in_forward_direction)
-    {
+    { // add (forward) segments or (forward,backward) for non-split edges in backward direction
        util::for_each_pair(
            nodes.cbegin(),
            nodes.cend(),
@@ -355,8 +358,8 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
            });
    }

-    if (in_backward_direction || split_edge)
-    {
+    if (in_backward_direction && (!in_forward_direction || split_edge))
+    { // add (backward) segments for split edges or not in forward direction
        util::for_each_pair(
            nodes.cbegin(),
            nodes.cend(),
@@ -247,7 +247,9 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
        "weight_name",
        sol::property(&ProfileProperties::SetWeightName, &ProfileProperties::GetWeightName),
        "max_turn_weight",
-        sol::property(&ProfileProperties::GetMaxTurnWeight));
+        sol::property(&ProfileProperties::GetMaxTurnWeight),
+        "force_split_edges",
+        &ProfileProperties::force_split_edges);

    context.state.new_usertype<std::vector<std::string>>(
        "vector",
@@ -330,12 +332,6 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
        sol::property(&ExtractionWay::GetTurnLanesForward, &ExtractionWay::SetTurnLanesForward),
        "turn_lanes_backward",
        sol::property(&ExtractionWay::GetTurnLanesBackward, &ExtractionWay::SetTurnLanesBackward),
-        "roundabout",
-        &ExtractionWay::roundabout,
-        "circular",
-        &ExtractionWay::circular,
-        "is_startpoint",
-        &ExtractionWay::is_startpoint,
        "duration",
        &ExtractionWay::duration,
        "weight",
@@ -343,13 +339,26 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
        "road_classification",
        &ExtractionWay::road_classification,
        "forward_mode",
-        sol::property(&ExtractionWay::get_forward_mode, &ExtractionWay::set_forward_mode),
+        sol::property([](const ExtractionWay &way) { return way.forward_travel_mode; },
+                      [](ExtractionWay &way, TravelMode mode) { way.forward_travel_mode = mode; }),
        "backward_mode",
-        sol::property(&ExtractionWay::get_backward_mode, &ExtractionWay::set_backward_mode),
+        sol::property([](const ExtractionWay &way) { return way.backward_travel_mode; },
+                      [](ExtractionWay &way, TravelMode mode) { way.backward_travel_mode = mode; }),
+        "roundabout",
+        sol::property([](const ExtractionWay &way) { return way.roundabout; },
+                      [](ExtractionWay &way, bool flag) { way.roundabout = flag; }),
+        "circular",
+        sol::property([](const ExtractionWay &way) { return way.circular; },
+                      [](ExtractionWay &way, bool flag) { way.circular = flag; }),
+        "is_startpoint",
+        sol::property([](const ExtractionWay &way) { return way.is_startpoint; },
+                      [](ExtractionWay &way, bool flag) { way.is_startpoint = flag; }),
        "forward_restricted",
-        &ExtractionWay::forward_restricted,
+        sol::property([](const ExtractionWay &way) { return way.forward_restricted; },
+                      [](ExtractionWay &way, bool flag) { way.forward_restricted = flag; }),
        "backward_restricted",
-        &ExtractionWay::backward_restricted);
+        sol::property([](const ExtractionWay &way) { return way.backward_restricted; },
+                      [](ExtractionWay &way, bool flag) { way.backward_restricted = flag; }));

    context.state.new_usertype<ExtractionSegment>("ExtractionSegment",
                                                  "source",
@@ -20,7 +20,7 @@ target_link_libraries(node-osrm osrm)
 # node-osrm artifacts in ${BINDING_DIR} to depend targets on
 set(ARTIFACTS "")

-set(OSRM_BINARIES osrm-extract osrm-contract osrm-routed osrm-datastore osrm-components)
+set(OSRM_BINARIES osrm-extract osrm-contract osrm-routed osrm-datastore osrm-components osrm-partition osrm-customize)
 foreach(binary ${OSRM_BINARIES})
  add_custom_command(OUTPUT ${BINDING_DIR}/${binary}
                     COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${binary}> ${BINDING_DIR}
@@ -48,15 +48,14 @@ NAN_MODULE_INIT(Engine::Init)
    Nan::Set(target, whoami, fn);
 }

+// clang-format off
 /**
 *
- * The `OSRM` method is the main constructor for creating an OSRM instance. An OSRM instance
- * requires a `.osrm` network,
- * which is prepared by the OSRM Backend C++ library. Once you have a complete `network.osrm` file,
- * you can calculate
- * networks in javascript with this library using the methods below. To create an OSRM instance with
- * your network
- * you need to construct an instance like this:
+ * The `OSRM` method is the main constructor for creating an OSRM instance.
+ * An OSRM instance requires a `.osrm` dataset, which is prepared by the OSRM toolchain.
+ * The documentation on `osrm-extract` and `osrm-contract` for more information.
+ * Once you have a complete `network.osrm` file, you can calculate routes in javascript with this library using the methods below.
+ * To create an OSRM instance with your network you need to construct an instance like this:
 *
 * ```javascript
 * var osrm = new OSRM('network.osrm');
@@ -78,27 +77,18 @@ NAN_MODULE_INIT(Engine::Init)
 * Each OSRM method (except for `OSRM.tile()`) has set of general options as well as unique options,
 * outlined below.
 *
- * | Option      | Values                                                  | Description
- * | Format                                                                         |
- * | ----------- | ------------------------------------------------------- |
- * ------------------------------------------------------------------------------------------------------
- * | ------------------------------------------------------------------------------ |
- * | coordinates | `array` of `coordinate` elements: `[{coordinate}, ...]` | The coordinates this
- * request will use.                                                                 | `array` with
- * `[{lon},{lat}]` values, in decimal degrees                        |
- * | bearings    | `array` of `bearing` elements: `[{bearing}, ...]`       | Limits the search to
- * segments with given bearing in degrees towards true north in clockwise direction. | `null` or
- * `array` with `[{value},{range}]` `integer 0 .. 360,integer 0 .. 180` |
- * | radiuses    | `array` of `radius` elements: `[{radius}, ...]`         | Limits the search to
- * given radius in meters.                                                           | `null` or
- * `double >= 0` or `unlimited` (default)                               |
- * | hints       | `array` of `hint` elements: `[{hint}, ...]`             | Hint to derive position
- * in street network.                                                             | Base64 `string`
- * |
+ * | Option      | Values           | Description  | Format |
+ * | ----------- | -----------------| ------------ | -------|
+ * | coordinates | `array` of `coordinate` elements: `[{coordinate}, ...]` | The coordinates this request will use. | `array` with `[{lon},{lat}]` values, in decimal degrees  |
+ * | bearings    | `array` of `bearing` elements: `[{bearing}, ...]`       | Limits the search to segments with given bearing in degrees towards true north in clockwise direction. | `null` or `array` with `[{value},{range}]` `integer 0 .. 360,integer 0 .. 180` |
+ * | radiuses    | `array` of `radius` elements: `[{radius}, ...]`         | Limits the search to given radius in meters. | `null` or `double >= 0` or `unlimited` (default) |
+ * | hints       | `array` of `hint` elements: `[{hint}, ...]`             | Hint to derive position in street network. | Base64 `string` |
 *
 * @class OSRM
 *
+ *
 */
+// clang-format on
 NAN_METHOD(Engine::New)
 {
    if (info.IsConstructCall())
@@ -195,6 +185,7 @@ inline void async(const Nan::FunctionCallbackInfo<v8::Value> &info,
    Nan::AsyncQueueWorker(new Worker{self->this_, std::move(params), service, callback});
 }

+// clang-format off
 /**
 * Returns the fastest route between two or more coordinates while visiting the waypoints in order.
 *
@@ -205,19 +196,14 @@ inline void async(const Nan::FunctionCallbackInfo<v8::Value> &info,
 * *Please note that even if an alternative route is requested, a result cannot be guaranteed.*
 * @param {Boolean} [options.steps=false] Return route steps for each route leg.
 * @param {Boolean} or {Array} [options.annotations=false] Return annotations for each route leg.
- * Can be `false`, `true` or an array with strings of `duration`, `nodes`, `distance`, `weight`,
- * `datasources`, `speed`.
- * @param {String} [options.geometries=polyline] Returned route geometry format (influences overview
- * and per step). Can also be `geojson`.
- * @param {String} [options.overview=simplified] Add overview geometry either `full`, `simplified`
- * according to highest zoom level it could be display on, or not at all (`false`).
- * @param {Boolean} [options.continue_straight] Forces the route to keep going straight at waypoints
- * and don't do a uturn even if it would be faster. Default value depends on the profile.
- * `null`/`true`/`false`
+ *        Can be `false`, `true` or an array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed`.
+ * @param {String} [options.geometries=polyline] Returned route geometry format (influences overview and per step). Can also be `geojson`.
+ * @param {String} [options.overview=simplified] Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`).
+ * @param {Boolean} [options.continue_straight] Forces the route to keep going straight at waypoints and don't do a uturn even if it would be faster. Default value depends on the profile.
+ *                  `null`/`true`/`false`
 * @param {Function} callback
 *
- * @returns {Object} An array of [Waypoint](#waypoint) objects representing all waypoints in order
- * AND an array of [`Route`](#route) objects ordered by descending recommendation rank.
+ * @returns {Object} An array of [Waypoint](#waypoint) objects representing all waypoints in order AND an array of [`Route`](#route) objects ordered by descending recommendation rank.
 *
 * @example
 * var osrm = new OSRM("berlin-latest.osrm");
@@ -227,11 +213,13 @@ inline void async(const Nan::FunctionCallbackInfo<v8::Value> &info,
 *   console.log(result.routes); // array of Route objects ordered by descending recommendation rank
 * });
 */
+// clang-format on
 NAN_METHOD(Engine::route) //
 {
    async(info, &argumentsToRouteParameter, &osrm::OSRM::Route, true);
 }

+// clang-format off
 /**
 * Snaps a coordinate to the street network and returns the nearest n matches.
 *
@@ -245,11 +233,8 @@ NAN_METHOD(Engine::route) //
 * @param {Function} callback
 *
 * @returns {Object} containing `waypoints`.
- * **`waypoints`**: array of [`Ẁaypoint`](#waypoint) objects sorted by distance to the input
- * coordinate.
- * Each object has an additional `distance` property, which is the distance in meters to the
- * supplied
- * input coordinate.
+ * **`waypoints`**: array of [`Ẁaypoint`](#waypoint) objects sorted by distance to the input coordinate.
+ *                  Each object has an additional `distance` property, which is the distance in meters to the supplied input coordinate.
 *
 * @example
 * var osrm = new OSRM('network.osrm');
@@ -262,11 +247,13 @@ NAN_METHOD(Engine::route) //
 *   console.log(response.waypoints); // array of Waypoint objects
 * });
 */
+// clang-format on
 NAN_METHOD(Engine::nearest) //
 {
    async(info, &argumentsToNearestParameter, &osrm::OSRM::Nearest, false);
 }

+// clang-format off
 /**
 * Computes duration tables for the given locations. Allows for both symmetric and asymmetric
 * tables.
@@ -282,11 +269,10 @@ NAN_METHOD(Engine::nearest) //
 * @param {Function} callback
 *
 * @returns {Object} containing `durations`, `sources`, and `destinations`.
- * **`durations`**: array of arrays that stores the matrix in row-major order. `durations[i][j]`
- * gives the travel time from the i-th waypoint to the j-th waypoint. Values are given in seconds.
+ * **`durations`**: array of arrays that stores the matrix in row-major order. `durations[i][j]` gives the travel time from the i-th waypoint to the j-th waypoint.
+ *                  Values are given in seconds.
 * **`sources`**: array of [`Ẁaypoint`](#waypoint) objects describing all sources in order.
- * **`destinations`**: array of [`Ẁaypoint`](#waypoint) objects describing all destinations in
- * order.
+ * **`destinations`**: array of [`Ẁaypoint`](#waypoint) objects describing all destinations in order.
 *
 * @example
 * var osrm = new OSRM('network.osrm');
@@ -303,11 +289,13 @@ NAN_METHOD(Engine::nearest) //
 *   console.log(response.destinations); // array of Waypoint objects
 * });
 */
+// clang-format on
 NAN_METHOD(Engine::table) //
 {
    async(info, &argumentsToTableParameter, &osrm::OSRM::Table, true);
 }

+// clang-format off
 /**
 * This generates [Mapbox Vector Tiles](https://mapbox.com/vector-tiles) that can be viewed with a
 * vector-tile capable slippy-map viewer. The tiles contain road geometries and metadata that can
@@ -318,11 +306,9 @@ NAN_METHOD(Engine::table) //
 *
 * @name tile
 * @memberof OSRM
- * @param {Array} ZXY - an array consisting of `x`, `y`, and `z` values representing tile
- * coordinates like
- * [wiki.openstreetmap.org/wiki/Slippy_map_tilenames](https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames)
- * and are supported by vector tile viewers like [Mapbox GL
- * JS](https://www.mapbox.com/mapbox-gl-js/api/.
+ * @param {Array} ZXY - an array consisting of `x`, `y`, and `z` values representing tile coordinates like
+ *        [wiki.openstreetmap.org/wiki/Slippy_map_tilenames](https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames)
+ *        and are supported by vector tile viewers like [Mapbox GL JS](https://www.mapbox.com/mapbox-gl-js/api/).
 * @param {Function} callback
 *
 * @returns {Buffer} contains a Protocol Buffer encoded vector tile.
@@ -334,11 +320,13 @@ NAN_METHOD(Engine::table) //
 *   fs.writeFileSync('./tile.vector.pbf', response); // write the buffer to a file
 * });
 */
+// clang-format on
 NAN_METHOD(Engine::tile)
 {
    async(info, &argumentsToTileParameters, &osrm::OSRM::Tile, {/*unused*/});
 }

+// clang-format off
 /**
 * Map matching matches given GPS points to the road network in the most plausible way.
 * Please note the request might result multiple sub-traces. Large jumps in the timestamps
@@ -351,31 +339,21 @@ NAN_METHOD(Engine::tile)
 * @param {Object} options - Object literal containing parameters for the match query.
 * @param {Boolean} [options.steps=false] Return route steps for each route.
 * @param {Boolean} or {Array} [options.annotations=false] Return annotations for each route leg.
- * Can be `false`, `true` or an array with strings of `duration`, `nodes`, `distance`, `weight`,
- * `datasources`, `speed`.
- * @param {String} [options.geometries=polyline] Returned route geometry format (influences overview
- * and per step). Can also be `geojson`.
- * @param {String} [options.overview=simplified] Add overview geometry either `full`, `simplified`
- * according to highest zoom level it could be display on, or not at all (`false`).
- * @param {Array<Number>} [options.timestamps] Timestamp of the input location (integers, UNIX-like
- * timestamp).
- * @param {Array} [options.radiuses] Standard deviation of GPS precision used for map matching.
- * If applicable use GPS accuracy (`double >= 0`, default `5m`).
+ *        Can be `false`, `true` or an array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed`.
+ * @param {String} [options.geometries=polyline] Returned route geometry format (influences overview and per step). Can also be `geojson`.
+ * @param {String} [options.overview=simplified] Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`).
+ * @param {Array<Number>} [options.timestamps] Timestamp of the input location (integers, UNIX-like timestamp).
+ * @param {Array} [options.radiuses] Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy (`double >= 0`, default `5m`).
 * @param {Function} callback
 *
 * @returns {Object} containing `tracepoints` and `matchings`.
- * **`tracepoints`** Array of [`Ẁaypoint`](#waypoint) objects representing all points of the trace
- * in order.
- * If the trace point was ommited by map matching because it is an outlier, the entry will be null.
- * Each
- * `Waypoint` object includes two additional properties, 1) `matchings_index`: Index to the
- * [`Route`](#route) object in matchings the sub-trace was matched to, 2) `waypoint_index`: Index of
- * the waypoint inside the matched route.
- * **`matchings`** is an array of [`Route`](#route) objects that
- * assemble the trace. Each `Route` object has an additional `confidence` property, which is the
- * confidence of
- * the matching. float value between `0` and `1`. `1` is very confident that the matching is
- * correct.
+ * **`tracepoints`** Array of [`Ẁaypoint`](#waypoint) objects representing all points of the trace in order.
+ *                   If the trace point was ommited by map matching because it is an outlier, the entry will be null.
+ *                   Each `Waypoint` object includes two additional properties, 1) `matchings_index`: Index to the
+ *                   [`Route`](#route) object in matchings the sub-trace was matched to, 2) `waypoint_index`: Index of
+ *                   the waypoint inside the matched route.
+ * **`matchings`** is an array of [`Route`](#route) objects that assemble the trace. Each `Route` object has an additional `confidence` property,
+ *                 which is the confidence of the matching. float value between `0` and `1`. `1` is very confident that the matching is correct.
 *
 * @example
 * var osrm = new OSRM('network.osrm');
@@ -390,11 +368,13 @@ NAN_METHOD(Engine::tile)
 * });
 *
 */
+// clang-format on
 NAN_METHOD(Engine::match) //
 {
    async(info, &argumentsToMatchParameter, &osrm::OSRM::Match, true);
 }

+// clang-format off
 /**
 * The trip plugin solves the Traveling Salesman Problem using a greedy heuristic
 * (farthest-insertion algorithm) for 10 or * more waypoints and uses brute force for less than 10
@@ -406,11 +386,9 @@ NAN_METHOD(Engine::match) //
 * @memberof OSRM
 * @param {Object} options - Object literal containing parameters for the trip query.
 * @param {Boolean} [options.steps=false] Return route steps for each route.
- * @param {Boolean} or {Array} [options.annotations=false] Return annotations for each route leg.
- * Can be `false`, `true` or an array with strings of `duration`, `nodes`, `distance`, `weight`,
- * `datasources`, `speed`.
- * @param {String} [options.geometries=polyline] Returned route geometry format (influences overview
- * and per step). Can also be `geojson`.
+ * @param {Boolean} or {Array} [options.annotations=false] Return annotations for each route leg.  Can be `false`,
+ *        `true` or an array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed`.
+ * @param {String} [options.geometries=polyline] Returned route geometry format (influences overview and per step). Can also be `geojson`.
 * @param {String} [options.overview=simplified] Add overview geometry either `full`, `simplified`
 * @param {Function} callback
 * @param {Boolean} [options.roundtrip=true] Return route is a roundtrip.
@@ -418,11 +396,10 @@ NAN_METHOD(Engine::match) //
 * @param {String} [options.destination=any] Return route ends at `any` or `last` coordinate.
 *
 * @returns {Object} containing `waypoints` and `trips`.
- * **`waypoints`**: an array of [`Waypoint`](#waypoint) objects representing all waypoints in input
- * order.
- * Each Waypoint object has the following additional properties, 1) `trips_index`: index to trips of
- * the
- * sub-trip the point was matched to, and 2) `waypoint_index`: index of the point in the trip.
+ * **`waypoints`**: an array of [`Waypoint`](#waypoint) objects representing all waypoints in input order.
+ *                  Each Waypoint object has the following additional properties,
+ *                  1) `trips_index`: index to trips of the sub-trip the point was matched to,
+ *                  and 2) `waypoint_index`: index of the point in the trip.
 * **`trips`**: an array of [`Route`](#route) objects that assemble the trace.
 *
 * @example
@@ -439,6 +416,7 @@ NAN_METHOD(Engine::match) //
 *   console.log(response.trips); // array of Route objects
 * });
 */
+// clang-format on
 NAN_METHOD(Engine::trip) //
 {
    async(info, &argumentsToTripParameter, &osrm::OSRM::Trip, true);
@@ -456,7 +434,7 @@ NAN_METHOD(Engine::trip) //
 * @memberof Responses
 *
 * @param {documentation} exteral in
- * [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#route)
+ * [`osrm-backend`](../http.md#route)
 *
 */

@@ -467,7 +445,7 @@ NAN_METHOD(Engine::trip) //
 * @memberof Responses
 *
 * @param {documentation} exteral in
- * [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#routeleg)
+ * [`osrm-backend`](../http.md#routeleg)
 *
 */

@@ -108,12 +108,12 @@ int Partitioner::Run(const PartitionConfig &config)
        makeBisectionGraph(compressed_node_based_graph.coordinates,
                           adaptToBisectionEdge(std::move(compressed_node_based_graph.edges)));

-    util::Log() << " running partition: " << config.minimum_cell_size << " " << config.balance
+    util::Log() << " running partition: " << config.max_cell_sizes.front() << " " << config.balance
                << " " << config.boundary_factor << " " << config.num_optimizing_cuts << " "
                << config.small_component_size
                << " # max_cell_size balance boundary cuts small_component_size";
    RecursiveBisection recursive_bisection(graph,
-                                           config.minimum_cell_size,
+                                           config.max_cell_sizes.front(),
                                           config.balance,
                                           config.boundary_factor,
                                           config.num_optimizing_cuts,
@@ -161,11 +161,7 @@ int Partitioner::Run(const PartitionConfig &config)
    std::vector<Partition> partitions;
    std::vector<std::uint32_t> level_to_num_cells;
    std::tie(partitions, level_to_num_cells) =
-        bisectionToPartition(edge_based_partition_ids,
-                             {config.minimum_cell_size,
-                              config.minimum_cell_size * 32,
-                              config.minimum_cell_size * 32 * 16,
-                              config.minimum_cell_size * 32 * 16 * 32});
+        bisectionToPartition(edge_based_partition_ids, config.max_cell_sizes);

    auto num_unconnected = removeUnconnectedBoundaryNodes(*edge_based_graph, partitions);
    util::Log() << "Fixed " << num_unconnected << " unconnected nodes";
@@ -8,11 +8,15 @@

 #include <tbb/task_scheduler_init.h>

+#include <boost/algorithm/string/join.hpp>
 #include <boost/assert.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
+#include <boost/range/adaptor/transformed.hpp>

 #include <iostream>
+#include <iterator>
+#include <regex>

 using namespace osrm;

@@ -23,7 +27,48 @@ enum class return_code : unsigned
    exit
 };

-return_code parseArguments(int argc, char *argv[], partition::PartitionConfig &partition_config)
+struct MaxCellSizesArgument
+{
+    std::vector<size_t> value;
+};
+
+std::ostream &operator<<(std::ostream &os, const MaxCellSizesArgument &arg)
+{
+    auto to_string = [](std::size_t x) { return std::to_string(x); };
+    return os << boost::algorithm::join(arg.value | boost::adaptors::transformed(to_string), ",");
+}
+
+void validate(boost::any &v, const std::vector<std::string> &values, MaxCellSizesArgument *, int)
+{
+    using namespace boost::program_options;
+    using namespace boost::adaptors;
+
+    // Make sure no previous assignment to 'v' was made.
+    validators::check_first_occurrence(v);
+    // Extract the first string from 'values'. If there is more than
+    // one string, it's an error, and exception will be thrown.
+    const std::string &s = validators::get_single_string(values);
+
+    std::regex re(",");
+    std::vector<size_t> output;
+    std::transform(std::sregex_token_iterator(s.begin(), s.end(), re, -1),
+                   std::sregex_token_iterator(),
+                   std::back_inserter(output),
+                   [](const auto &x) {
+                       try
+                       {
+                           return boost::lexical_cast<std::size_t>(x);
+                       }
+                       catch (const boost::bad_lexical_cast &)
+                       {
+                           throw validation_error(validation_error::invalid_option_value);
+                       }
+                   });
+
+    v = boost::any(MaxCellSizesArgument{output});
+}
+
+return_code parseArguments(int argc, char *argv[], partition::PartitionConfig &config)
 {
    // declare a group of options that will be allowed only on command line
    boost::program_options::options_description generic_options("Options");
@@ -34,40 +79,41 @@ return_code parseArguments(int argc, char *argv[], partition::PartitionConfig &p
    config_options.add_options()
        //
        ("threads,t",
-         boost::program_options::value<unsigned int>(&partition_config.requested_num_threads)
+         boost::program_options::value<unsigned int>(&config.requested_num_threads)
             ->default_value(tbb::task_scheduler_init::default_num_threads()),
         "Number of threads to use")
        //
-        ("min-cell-size",
-         boost::program_options::value<std::size_t>(&partition_config.minimum_cell_size)
-             ->default_value(128),
-         "Bisection termination citerion based on cell size")
-        //
        ("balance",
-         boost::program_options::value<double>(&partition_config.balance)->default_value(1.2),
+         boost::program_options::value<double>(&config.balance)->default_value(config.balance),
         "Balance for left and right side in single bisection")
        //
        ("boundary",
-         boost::program_options::value<double>(&partition_config.boundary_factor)
-             ->default_value(0.25),
+         boost::program_options::value<double>(&config.boundary_factor)
+             ->default_value(config.boundary_factor),
         "Percentage of embedded nodes to contract as sources and sinks")
        //
        ("optimizing-cuts",
-         boost::program_options::value<std::size_t>(&partition_config.num_optimizing_cuts)
-             ->default_value(10),
+         boost::program_options::value<std::size_t>(&config.num_optimizing_cuts)
+             ->default_value(config.num_optimizing_cuts),
         "Number of cuts to use for optimizing a single bisection")
        //
        ("small-component-size",
-         boost::program_options::value<std::size_t>(&partition_config.small_component_size)
-             ->default_value(1000),
-         "Size threshold for small components.");
+         boost::program_options::value<std::size_t>(&config.small_component_size)
+             ->default_value(config.small_component_size),
+         "Size threshold for small components.")
+        //
+        ("max-cell-sizes",
+         boost::program_options::value<MaxCellSizesArgument>()->default_value(
+             MaxCellSizesArgument{config.max_cell_sizes}),
+         "Maximum cell sizes starting from the level 1. The first cell size value is a bisection "
+         "termination citerion");

    // hidden options, will be allowed on command line, 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>(&partition_config.base_path),
+        boost::program_options::value<boost::filesystem::path>(&config.base_path),
        "Input file in .osrm format");

    // positional option
@@ -119,6 +165,18 @@ return_code parseArguments(int argc, char *argv[], partition::PartitionConfig &p
        return return_code::fail;
    }

+    if (option_variables.count("max-cell-sizes"))
+    {
+        config.max_cell_sizes = option_variables["max-cell-sizes"].as<MaxCellSizesArgument>().value;
+
+        if (!std::is_sorted(config.max_cell_sizes.begin(), config.max_cell_sizes.end()))
+        {
+            util::Log(logERROR)
+                << "The maximum cell sizes array must be sorted in non-descending order.";
+            return return_code::fail;
+        }
+    }
+
    return return_code::ok;
 }

@@ -1,6 +1,8 @@
 var OSRM = require('../../');
 var test = require('tape');
 var berlin_path = require('./osrm-data-path').data_path;
+var berlin_mld_path = require('./osrm-data-path').mld_data_path;
+var berlin_corech_path = require('./osrm-data-path').corech_data_path;

 test('constructor: throws if new keyword is not used', function(assert) {
    assert.plan(1);
@@ -23,7 +25,7 @@ test('constructor: does not accept more than one parameter', function(assert) {
 test('constructor: throws if necessary files do not exist', function(assert) {
    assert.plan(1);
    assert.throws(function() { new OSRM("missing.osrm"); },
-        /Invalid file paths/);
+        /Error opening missing.osrm.names/);
 });

 test('constructor: takes a shared memory argument', function(assert) {
@@ -34,22 +36,52 @@ test('constructor: takes a shared memory argument', function(assert) {

 test('constructor: throws if shared_memory==false with no path defined', function(assert) {
    assert.plan(1);
-    assert.throws(function() { var osrm = new OSRM({shared_memory: false}); },
+    assert.throws(function() { new OSRM({shared_memory: false}); },
        /Shared_memory must be enabled if no path is specified/);
 });

 test('constructor: throws if given a non-bool shared_memory option', function(assert) {
    assert.plan(1);
-    assert.throws(function() { var osrm = new OSRM({path: berlin_path, shared_memory: "a"}); },
+    assert.throws(function() { new OSRM({path: berlin_path, shared_memory: 'a'}); },
        /Shared_memory option must be a boolean/);
 });

 test('constructor: throws if given a non-string/obj argument', function(assert) {
    assert.plan(1);
-    assert.throws(function() { var osrm = new OSRM(true); },
+    assert.throws(function() { new OSRM(true); },
        /Parameter must be a path or options object/);
 });

+test('constructor: throws if given an unkown algorithm', function(assert) {
+    assert.plan(1);
+    assert.throws(function() { new OSRM({algorithm: 'Foo', shared_memory: true}); },
+        /algorithm option must be one of 'CH', 'CoreCH', or 'MLD'/);
+});
+
+test('constructor: throws if given an invalid algorithm', function(assert) {
+    assert.plan(1);
+    assert.throws(function() { new OSRM({algorithm: 3, shared_memory: true}); },
+        /algorithm option must be a string and one of 'CH', 'CoreCH', or 'MLD'/);
+});
+
+test('constructor: loads MLD if given as algorithm', function(assert) {
+    assert.plan(1);
+    var osrm = new OSRM({algorithm: 'MLD', path: berlin_mld_path});
+    assert.ok(osrm);
+});
+
+test('constructor: loads CH if given as algorithm', function(assert) {
+    assert.plan(1);
+    var osrm = new OSRM({algorithm: 'CH', path: berlin_path});
+    assert.ok(osrm);
+});
+
+test('constructor: loads CoreCH if given as algorithm', function(assert) {
+    assert.plan(1);
+    var osrm = new OSRM({algorithm: 'CoreCH', path: berlin_corech_path});
+    assert.ok(osrm);
+});
+
 require('./route.js');
 require('./trip.js');
 require('./match.js');
@@ -2,7 +2,11 @@ var path = require('path');

 if (process.env.OSRM_DATA_PATH !== undefined) {
    exports.data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "ch/berlin.osrm");
+    exports.mld_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "mld/berlin.osrm");
+    exports.corech_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "corech/berlin.osrm");
    console.log('Setting custom data path to ' + exports.data_path);
 } else {
    exports.data_path = path.resolve(path.join(__dirname, "../data/ch/berlin.osrm"));
+    exports.mld_data_path = path.resolve(path.join(__dirname, "../data/mld/berlin.osrm"));
+    exports.corech_data_path = path.resolve(path.join(__dirname, "../data/corech/berlin.osrm"));
 }
@@ -1,6 +1,8 @@
 var OSRM = require('../../');
 var test = require('tape');
 var berlin_path = require('./osrm-data-path').data_path;
+var berlin_mld_path = require('./osrm-data-path').mld_data_path;
+var berlin_corech_path = require('./osrm-data-path').corech_data_path;

 test('route: routes Berlin', function(assert) {
    assert.plan(5);
@@ -14,6 +16,30 @@ test('route: routes Berlin', function(assert) {
    });
 });

+test('route: routes Berlin on MLD', function(assert) {
+    assert.plan(5);
+    var osrm = new OSRM({path: berlin_mld_path, algorithm: 'MLD'});
+    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
+        assert.ifError(err);
+        assert.ok(route.waypoints);
+        assert.ok(route.routes);
+        assert.ok(route.routes.length);
+        assert.ok(route.routes[0].geometry);
+    });
+});
+
+test('route: routes Berlin on CoreCH', function(assert) {
+    assert.plan(5);
+    var osrm = new OSRM({path: berlin_corech_path, algorithm: 'CoreCH'});
+    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
+        assert.ifError(err);
+        assert.ok(route.waypoints);
+        assert.ok(route.routes);
+        assert.ok(route.routes.length);
+        assert.ok(route.routes[0].geometry);
+    });
+});
+
 test('route: throws with too few or invalid args', function(assert) {
    assert.plan(3);
    var osrm = new OSRM(berlin_path);
@@ -0,0 +1,132 @@
+#include "engine/api/match_parameters_tidy.hpp"
+
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+BOOST_AUTO_TEST_SUITE(tidy_test)
+
+using namespace osrm;
+using namespace osrm::util;
+using namespace osrm::engine::api;
+
+BOOST_AUTO_TEST_CASE(two_item_trace_already_tidied_test)
+{
+    MatchParameters params;
+    params.coordinates.emplace_back(FloatLongitude{13.207993}, FloatLatitude{52.446379});
+    params.coordinates.emplace_back(FloatLongitude{13.231658}, FloatLatitude{52.465416});
+
+    params.timestamps.emplace_back(1477090402);
+    params.timestamps.emplace_back(1477090663);
+
+    tidy::Thresholds thresholds;
+    thresholds.distance_in_meters = 15.;
+    thresholds.duration_in_seconds = 5;
+
+    auto result = tidy::tidy(params, thresholds);
+
+    BOOST_CHECK_EQUAL(result.can_be_removed.size(), 2);
+    BOOST_CHECK_EQUAL(result.tidied_to_original.size(), 2);
+
+    BOOST_CHECK(result.can_be_removed[0] == false);
+    BOOST_CHECK(result.can_be_removed[1] == false);
+    BOOST_CHECK_EQUAL(result.tidied_to_original[0], 0);
+    BOOST_CHECK_EQUAL(result.tidied_to_original[1], 1);
+}
+
+BOOST_AUTO_TEST_CASE(two_item_trace_needs_tidiying_test)
+{
+    MatchParameters params;
+    params.coordinates.emplace_back(FloatLongitude{13.207993}, FloatLatitude{52.446379});
+    params.coordinates.emplace_back(FloatLongitude{13.231658}, FloatLatitude{52.465416});
+
+    params.timestamps.emplace_back(1477090402);
+    params.timestamps.emplace_back(1477090663);
+
+    tidy::Thresholds thresholds;
+    thresholds.distance_in_meters = 5000;
+    thresholds.duration_in_seconds = 5 * 60;
+
+    auto result = tidy::tidy(params, thresholds);
+
+    BOOST_CHECK_EQUAL(result.can_be_removed.size(), 2);
+    BOOST_CHECK_EQUAL(result.tidied_to_original.size(), 1);
+
+    BOOST_CHECK_EQUAL(result.can_be_removed[0], false);
+    BOOST_CHECK_EQUAL(result.can_be_removed[1], true);
+    BOOST_CHECK_EQUAL(result.tidied_to_original[0], 0);
+}
+
+BOOST_AUTO_TEST_CASE(two_blobs_in_traces_needs_tidiying_test)
+{
+    MatchParameters params;
+
+    params.coordinates.emplace_back(FloatLongitude{13.207993}, FloatLatitude{52.446379});
+    params.coordinates.emplace_back(FloatLongitude{13.207994}, FloatLatitude{52.446380});
+    params.coordinates.emplace_back(FloatLongitude{13.207995}, FloatLatitude{52.446381});
+
+    params.coordinates.emplace_back(FloatLongitude{13.231658}, FloatLatitude{52.465416});
+    params.coordinates.emplace_back(FloatLongitude{13.231659}, FloatLatitude{52.465417});
+    params.coordinates.emplace_back(FloatLongitude{13.231660}, FloatLatitude{52.465417});
+
+    params.timestamps.emplace_back(1477090402);
+    params.timestamps.emplace_back(1477090403);
+    params.timestamps.emplace_back(1477090404);
+
+    params.timestamps.emplace_back(1477090661);
+    params.timestamps.emplace_back(1477090662);
+    params.timestamps.emplace_back(1477090663);
+
+    tidy::Thresholds thresholds;
+    thresholds.distance_in_meters = 15;
+    thresholds.duration_in_seconds = 5;
+
+    auto result = tidy::tidy(params, thresholds);
+
+    BOOST_CHECK_EQUAL(result.can_be_removed.size(), params.coordinates.size());
+    BOOST_CHECK_EQUAL(result.tidied_to_original.size(), 2);
+
+    BOOST_CHECK_EQUAL(result.tidied_to_original[0], 0);
+    BOOST_CHECK_EQUAL(result.tidied_to_original[1], 3);
+
+    const auto redundant = result.can_be_removed.count();
+    BOOST_CHECK_EQUAL(redundant, params.coordinates.size() - 2);
+
+    BOOST_CHECK_EQUAL(result.can_be_removed[0], false);
+    BOOST_CHECK_EQUAL(result.can_be_removed[3], false);
+}
+
+BOOST_AUTO_TEST_CASE(two_blobs_in_traces_needs_tidiying_no_timestamps_test)
+{
+    MatchParameters params;
+
+    params.coordinates.emplace_back(FloatLongitude{13.207993}, FloatLatitude{52.446379});
+    params.coordinates.emplace_back(FloatLongitude{13.207994}, FloatLatitude{52.446380});
+    params.coordinates.emplace_back(FloatLongitude{13.207995}, FloatLatitude{52.446381});
+
+    params.coordinates.emplace_back(FloatLongitude{13.231658}, FloatLatitude{52.465416});
+    params.coordinates.emplace_back(FloatLongitude{13.231659}, FloatLatitude{52.465417});
+    params.coordinates.emplace_back(FloatLongitude{13.231660}, FloatLatitude{52.465417});
+
+    tidy::Thresholds thresholds;
+    thresholds.distance_in_meters = 15;
+    thresholds.duration_in_seconds = 5;
+
+    auto result = tidy::tidy(params, thresholds);
+
+    BOOST_CHECK_EQUAL(result.can_be_removed.size(), params.coordinates.size());
+    BOOST_CHECK_EQUAL(result.tidied_to_original.size(), 2);
+    BOOST_CHECK_EQUAL(result.tidied_to_original[0], 0);
+    BOOST_CHECK_EQUAL(result.tidied_to_original[1], 3);
+
+    const auto redundant = result.can_be_removed.count();
+    BOOST_CHECK_EQUAL(redundant, params.coordinates.size() - 2);
+
+    BOOST_CHECK_EQUAL(result.can_be_removed[0], false);
+    BOOST_CHECK_EQUAL(result.can_be_removed[3], false);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
@@ -46,11 +46,11 @@ BOOST_AUTO_TEST_SUITE(multi_level_graph)

 BOOST_AUTO_TEST_CASE(check_edges_sorting)
 {
-    // node:                0  1  2  3  4  5  6  7  8  9 10 11 12
-    std::vector<CellID> l1{{0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6}};
-    std::vector<CellID> l2{{0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 4}};
-    std::vector<CellID> l3{{0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2}};
-    std::vector<CellID> l4{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}};
+    // node:                0  1  2  3  4  5  6  7  8  9 10 11 12 13
+    std::vector<CellID> l1{{0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6}};
+    std::vector<CellID> l2{{0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4}};
+    std::vector<CellID> l3{{0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2}};
+    std::vector<CellID> l4{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1}};
    MultiLevelPartition mlp{{l1, l2, l3, l4}, {7, 5, 3, 2}};

    std::vector<MockEdge> edges = {
@@ -69,7 +69,8 @@ BOOST_AUTO_TEST_CASE(check_edges_sorting)
        {9, 8},   //  i   i   i   i
        {10, 11}, //  i   i   i   i
        {11, 10}, //  i   i   i   i
-        {11, 12}  //  b   b   b   b
+        {11, 12}, //  b   b   b   b
+        {12, 13}  //  i   i   i   i
    };

    auto graph = makeGraph(mlp, edges);
@@ -97,7 +98,7 @@ BOOST_AUTO_TEST_CASE(check_edges_sorting)
    // the union of border and internal edge needs to equal the adjacent edges
    for (auto level : util::irange<LevelID>(0, 4))
    {
-        for (auto node : util::irange<NodeID>(0, 13))
+        for (auto node : util::irange<NodeID>(0, 14))
        {
            const auto adjacent = graph.GetAdjacentEdgeRange(node);
            const auto border = graph.GetBorderEdgeRange(level, node);
@@ -122,6 +123,7 @@ BOOST_AUTO_TEST_CASE(check_edges_sorting)
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(1, 10).size(), 0);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(1, 11).size(), 2);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(1, 12).size(), 1);
+    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(1, 13).size(), 0);

    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(2, 0).size(), 1);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(2, 1).size(), 0);
@@ -136,6 +138,7 @@ BOOST_AUTO_TEST_CASE(check_edges_sorting)
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(2, 10).size(), 0);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(2, 11).size(), 2);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(2, 12).size(), 1);
+    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(2, 13).size(), 0);

    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(3, 0).size(), 1);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(3, 1).size(), 0);
@@ -150,6 +153,7 @@ BOOST_AUTO_TEST_CASE(check_edges_sorting)
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(3, 10).size(), 0);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(3, 11).size(), 1);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(3, 12).size(), 1);
+    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(3, 13).size(), 0);

    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(4, 0).size(), 0);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(4, 1).size(), 0);
@@ -164,6 +168,7 @@ BOOST_AUTO_TEST_CASE(check_edges_sorting)
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(4, 10).size(), 0);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(4, 11).size(), 1);
    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(3, 12).size(), 1);
+    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(4, 13).size(), 0);

    CHECK_EQUAL_RANGE(graph.GetBorderEdgeRange(1, 0), graph.FindEdge(0, 4));
    CHECK_EQUAL_RANGE(graph.GetBorderEdgeRange(1, 3), graph.FindEdge(3, 7));
@@ -194,4 +199,25 @@ BOOST_AUTO_TEST_CASE(check_edges_sorting)
    CHECK_EQUAL_RANGE(graph.GetBorderEdgeRange(4, 12), graph.FindEdge(12, 11));
 }

+BOOST_AUTO_TEST_CASE(check_last_internal_edge)
+{
+    //                      a--b--c--d
+    std::vector<CellID> l1{{0, 0, 1, 1}};
+    std::vector<CellID> l2{{0, 0, 1, 1}};
+    MultiLevelPartition mlp{{l1, l2}, {2, 2}};
+
+    std::vector<MockEdge> edges = {{0, 1}, {1, 0}, {1, 2}, {2, 1}, {2, 3}, {3, 2}};
+
+    auto graph = makeGraph(mlp, edges);
+
+    auto all_edges = graph.GetAdjacentEdgeRange(3);
+    CHECK_EQUAL_COLLECTIONS(graph.GetBorderEdgeRange(0, 3), all_edges);
+    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(1, 3).size(), 0);
+    BOOST_CHECK_EQUAL(graph.GetBorderEdgeRange(2, 3).size(), 0);
+
+    BOOST_CHECK_EQUAL(graph.GetInternalEdgeRange(0, 3).size(), 0);
+    CHECK_EQUAL_COLLECTIONS(graph.GetInternalEdgeRange(1, 3), all_edges);
+    CHECK_EQUAL_COLLECTIONS(graph.GetInternalEdgeRange(2, 3), all_edges);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
Author	SHA1	Message	Date
Patrick Niklaus	e568b600f0	Tag a new latest version for publishing	2017-04-03 12:50:45 +00:00
Patrick Niklaus	273fd689ce	Always check local variables	2017-03-30 20:12:07 +00:00
Patrick Niklaus	0363d64722	Update releasing docs	2017-03-30 20:12:07 +00:00
Patrick Niklaus	d200507424	Fix travis.yml	2017-03-30 20:12:07 +00:00
Patrick Niklaus	fc84f605af	Switch from commit message publishing to tag-based publishing	2017-03-30 20:12:07 +00:00
Patrick Niklaus	927dea37bb	Fix publishing node binaries	2017-03-30 20:12:07 +00:00
Patrick Niklaus	de98ae57b7	Switch to yarn	2017-03-30 20:12:07 +00:00
Patrick Niklaus	614398ed6c	Integrate MLD in node bindings	2017-03-30 20:12:07 +00:00
Michael Krasnyk	2cd4ba9a0a	move split_edges to global properties	2017-03-30 11:20:13 +02:00
Michael Krasnyk	57d3f71bf9	added change log entry and documentation	2017-03-30 11:20:13 +02:00
Michael Krasnyk	8f8df969a2	use signed slope to distinguish uphills and downhills	2017-03-30 11:20:13 +02:00
Michael Krasnyk	e39dc3c464	adjust rasterbot test to check split_edges flag	2017-03-30 11:20:13 +02:00
Michael Krasnyk	dbc6535221	add split_edge flag in extracted ways	2017-03-30 11:20:13 +02:00
Michael Krasnyk	e262cac3e8	Flip source and target coordinates for segments in only backward direction	2017-03-29 22:05:37 +00:00
Michael Krasnyk	4ab3165ae3	Fix unnecessary duplication of backward segments for non-split edges for edges with the split flag false and in_backward_direction true if in_forward_direction is also true backward segments can be incorrectly duplicated	2017-03-29 22:05:37 +00:00
Michael Krasnyk	7a1a209168	use std::regex_token_iterator instead of boost tokenized	2017-03-29 10:23:42 +00:00
Michael Krasnyk	ac6f07a744	make adaptors::tokenized compatible with boost 1.54	2017-03-29 10:23:42 +00:00
Michael Krasnyk	dac929f8df	Make max-cell-sizes parameter a comma-separated list	2017-03-29 10:23:42 +00:00
MichalPP	ebd938a8fc	add kerb to foot.profile barrier whitelist	2017-03-29 10:25:28 +02:00
Michael Krasnyk	5ba54a62d6	Fix clang format for `3dcc713`	2017-03-28 13:39:22 +00:00
Michael Krasnyk	827a595b6c	Enable coverage reports for unit_tests	2017-03-28 10:40:13 +00:00
Michael Krasnyk	c03f74d8b0	Remove unused id parameter	2017-03-28 10:40:13 +00:00
Michael Krasnyk	f5393f44f7	Add minimal representative example for #3866	2017-03-28 10:40:13 +00:00
Patrick Niklaus	ad6e834992	Add regression test	2017-03-28 10:40:13 +00:00
Patrick Niklaus	3439b21177	Fix internal edges for nodes not in the boundary	2017-03-28 10:40:13 +00:00
Pepijn Schoen	730c809395	Fix Win tests by copying data explicitly to test/data	2017-03-28 12:08:49 +02:00
Emil Tin	5a2da798c8	fixes speed on cycleway+oneway #3853	2017-03-28 12:07:38 +02:00
Daniel J. Hofmann	c0e7f6e9f4	Documents the user having to be in the docker group for running our images	2017-03-28 12:05:09 +02:00
Richard Fairhurst	ed83d3ed13	More turn parameters as per @daniel-j-h's comment	2017-03-28 11:58:42 +02:00
Richard Fairhurst	aa1dff3fc4	Update _rate as per @TheMarex's comment	2017-03-28 11:58:42 +02:00
Richard Fairhurst	c1901e9689	Add new property from #3840	2017-03-28 11:58:42 +02:00
Richard Fairhurst	c6e6d9fa94	Explain parameters as per @daniel-j-h's suggestion	2017-03-28 11:58:42 +02:00
Richard Fairhurst	88eabb98b9	Document all options available to Lua profiles Recent improvements to OSRM have led to a lot of changes to the Lua scripting interface, and refactoring of the default profiles makes them slightly more abstract and difficult to grok for those writing profiles from scratch. This is therefore an attempt to fully document the attributes that can be read and set from Lua profiles. I've done it from my own understanding and from reading the source, but I may well have missed things or mistaken them!	2017-03-28 11:58:42 +02:00
Michael Krasnyk	3dcc7132b6	Add max-cell-sizes option to partitioner	2017-03-28 11:53:14 +02:00
Daniel Patterson	379380abd8	These don't need to be warning messages, debug is sufficient.	2017-03-22 10:41:10 +00:00
Lev Dragunov	497709da13	Review fixes	2017-03-22 10:39:36 +00:00
Lev Dragunov	b95a58591d	Tidying matching without ts case	2017-03-22 10:39:36 +00:00
Lev Dragunov	5727b1387e	Test fixes	2017-03-22 10:39:36 +00:00
Lev Dragunov	221cd00b1a	Remove redundant bitsetting	2017-03-22 10:39:36 +00:00
Lev Dragunov	cce4f6344c	TODO fixes	2017-03-22 10:39:36 +00:00
Lev Dragunov	a49c6f433b	Cucumber tests	2017-03-22 10:39:36 +00:00
Lev Dragunov	ef308ac53a	Compilation fix.	2017-03-22 10:39:36 +00:00
Lev Dragunov	2fab696bb3	New tidying and gaps parameters.	2017-03-22 10:39:36 +00:00
Lev Dragunov	836a5066c2	CHANGELOG entry	2017-03-22 10:39:36 +00:00
Lev Dragunov	69422cc4e7	Clang formatting.	2017-03-22 10:39:36 +00:00
Lev Dragunov	e9c0987e8a	Integration #3149 and #3815	2017-03-22 10:39:36 +00:00
Daniel J. Hofmann	bd9eb76a2d	Transparently Tidy Traces in Map Matching, resolves #2840 . The Map Matching plugin currently has issues with: - high frequency traces and (performance) - blobs, think noise at traffic signals (correctness) This changeset implements trace-tidying transparently for the user. We hopefully will see both performance gains as well as better matches!	2017-03-22 10:39:36 +00:00
Lev Dragunov	441eae9df2	Tidying prarameter for the map matching plugin.	2017-03-22 10:39:36 +00:00