Merge branch 'trial/dragging' into develop

Conflicts:
	WebContent/OSRM.JSONP.js
	WebContent/OSRM.debug.js
	WebContent/main.html

.clang-format

@@ -1,54 +0,0 @@
----
-Language:        Cpp
-# BasedOnStyle:  LLVM
-AccessModifierOffset: -2
-ConstructorInitializerIndentWidth: 4
-AlignEscapedNewlinesLeft: false
-AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: true
-AlwaysBreakTemplateDeclarations: false
-AlwaysBreakBeforeMultilineStrings: false
-BreakBeforeBinaryOperators: false
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
-BinPackParameters: false
-ColumnLimit:     100
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-DerivePointerBinding: false
-ExperimentalAutoDetectBinPacking: false
-IndentCaseLabels: false
-MaxEmptyLinesToKeep: 1
-KeepEmptyLinesAtTheStartOfBlocks: true
-NamespaceIndentation: None
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakString: 1000
-PenaltyBreakFirstLessLess: 120
-PenaltyExcessCharacter: 1000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerBindsToType: false
-SpacesBeforeTrailingComments: 1
-Cpp11BracedListStyle: true
-Standard:        Cpp11
-IndentWidth:     4
-TabWidth:        8
-UseTab:          Never
-BreakBeforeBraces: Allman
-IndentFunctionDeclarationAfterType: false
-SpacesInParentheses: false
-SpacesInAngles:  false
-SpaceInEmptyParentheses: false
-SpacesInCStyleCastParentheses: false
-SpacesInContainerLiterals: true
-SpaceBeforeAssignmentOperators: true
-ContinuationIndentWidth: 4
-CommentPragmas:  '^ IWYU pragma:'
-ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-SpaceBeforeParens: ControlStatements
-...
-

.clang-tidy

@@ -1,4 +0,0 @@
----
-Checks:          '-clang-analyzer-*,google-*,llvm-*,misc-*,readability-*,-google-build-explicit-make-pair,-google-explicit-constructor,-google-readability-braces-around-statements,-google-readability-casting,-google-readability-namespace-comments,-google-readability-function,-google-readability-todo,-google-runtime-int,-llvm-namespace-comment,-llvm-header-guard,-llvm-twine-local,-misc-argument-comment,-readability-braces-around-statements,-readability-identifier-naming'
-...
-

.gitignore

@@ -1,80 +1,2 @@
-# pre compiled dependencies #
-#############################
-osrm-deps
-
-# Compiled source #
-###################
-*.com
-*.class
-*.dll
-*.exe
-*.o
-*.so
-
-# Packages #
-############
-# it's better to unpack these files and commit the raw source
-# git has its own built in compression methods
-*.7z
-*.dmg
-*.gz
-*.iso
-*.jar
-*.rar
-*.tar
-*.zip
-
-# Logs and databases #
-######################
-*.log
-*.sql
-*.sqlite
-
-# OS generated files #
-######################
-.DS_Store
-ehthumbs.db
-Icon?
-Thumbs.db
-
-# build related files #
-#######################
-/build/
-/cmake/postinst
-
-# Eclipse related files #
-#########################
-.setting*
-.scb
-.cproject
-.project
-
-# stxxl related files #
-#######################
-.stxxl
-stxxl.log
-stxxl.errlog
-
-# Compiled Binary Files #
-####################################
-/osrm-extract
-/osrm-io-benchmark
-/osrm-components
-/osrm-routed
-/osrm-datastore
-/osrm-prepare
-/osrm-unlock-all
-/osrm-cli
-/osrm-check-hsgr
-/osrm-springclean
-/nohup.out
-
-# Sandbox folder #
-###################
-/sandbox/
-
-/test/profile.lua
-
-# Deprecated config file #
-##########################
-/server.ini
+/.settings
+/.project

.travis.yml

@@ -1,146 +0,0 @@
-language: cpp
-sudo: required
-dist: trusty
-
-notifications:
-  email: false
-
-branches:
-  only:
-    - master
-    - develop
-
-matrix:
-  include:
-
-    # 1/ Linux Clang Builds
-
-    - os: linux
-      compiler: clang
-      addons: &clang38
-        apt:
-          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
-          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Release'
-
-    - os: linux
-      compiler: clang
-      addons: &clang38
-        apt:
-          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
-          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
-
-    - os: linux
-      compiler: clang
-      addons: *clang38
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug'
-
-
-    # 2/ Linux GCC Builds
-    - os: linux
-      compiler: gcc
-      addons: &gcc48
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='g++-4.8' BUILD_TYPE='Release'
-
-    - os: linux
-      compiler: gcc
-      addons: *gcc48
-      env: COMPILER='g++-4.8' BUILD_TYPE='Debug'
-
-
-    - os: linux
-      compiler: gcc
-      addons: &gcc5
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-5', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='g++-5' BUILD_TYPE='Release'
-
-    - os: linux
-      compiler: gcc
-      addons: &gcc5
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-5', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='g++-5' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
-
-    - os: linux
-      compiler: gcc
-      addons: *gcc5
-      env: COMPILER='g++-5' BUILD_TYPE='Debug'
-
-
-    # Disabled until tests all pass on OSX:
-    #
-    # 3/ OSX Clang Builds
-    #- os: osx
-    #  osx_image: xcode6.4
-    #  compiler: clang
-    #  env: COMPILER='clang++' BUILD_TYPE='Debug'
-
-    #- os: osx
-    #  osx_image: xcode6.4
-    #  compiler: clang
-    #  env: COMPILER='clang++' BUILD_TYPE='Release'
-
-    #- os: osx
-    #  osx_image: xcode6.4
-    #  compiler: clang
-    #  env: COMPILER='clang++' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
-
-    #- os: osx
-    #  osx_image: xcode7
-    #  compiler: clang
-    #  env: COMPILER='clang++' BUILD_TYPE='Debug'
-
-    #- os: osx
-    #  osx_image: xcode7
-    #  compiler: clang
-    #  env: COMPILER='clang++' BUILD_TYPE='Release'
-
-    #- os: osx
-    #  osx_image: xcode7
-    #  compiler: clang
-    #  env: COMPILER='clang++' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
-
-
-install:
-  - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
-  - mkdir -p ${DEPS_DIR} && cd ${DEPS_DIR}
-  - |
-    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
-      CMAKE_URL="http://www.cmake.org/files/v3.3/cmake-3.3.2-Linux-x86_64.tar.gz"
-      mkdir cmake && travis_retry wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake
-      export PATH=${DEPS_DIR}/cmake/bin:${PATH}
-
-      OSMOSIS_URL="http://bretth.dev.openstreetmap.org/osmosis-build/osmosis-latest.tgz"
-      mkdir osmosis && travis_retry wget --quiet -O - ${OSMOSIS_URL} | tar -xz -C osmosis
-      export PATH=${DEPS_DIR}/osmosis/bin:${PATH}
-
-    elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
-      brew install cmake boost libzip libstxxl libxml2 lua51 luabind tbb GDAL osmosis
-    fi
-
-before_script:
-  - cd ${TRAVIS_BUILD_DIR}
-  - rvm use 1.9.3
-  - gem install bundler
-  - bundle install
-  - mkdir build && cd build
-  - export CXX=${COMPILER}
-  - export OSRM_PORT=5000 OSRM_TIMEOUT=60
-  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} -DBUILD_TOOLS=1
-
-script:
-  - make --jobs=2
-  - make tests --jobs=2
-  - make benchmarks
-  - ./algorithm-tests
-  - ./datastructure-tests
-  - ./util-tests
-  - cd ..
-  - cucumber -p verify

CMakeLists.txt

@@ -1,442 +0,0 @@
-cmake_minimum_required(VERSION 2.8.8)
-
-if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE)
-  message(FATAL_ERROR "In-source builds are not allowed.
-Please create a directory and run cmake from there, passing the path to this source directory as the last argument.
-This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")
-endif()
-
-project(OSRM C CXX)
-set(OSRM_VERSION_MAJOR 4)
-set(OSRM_VERSION_MINOR 9)
-set(OSRM_VERSION_PATCH 0)
-
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-include(CheckCXXCompilerFlag)
-include(FindPackageHandleStandardArgs)
-
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
-set(bitness 32)
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  set(bitness 64)
-  message(STATUS "Building on a 64 bit system")
-else()
-  message(WARNING "Building on a 32 bit system is unsupported")
-endif()
-
-if(WIN32 AND MSVC_VERSION LESS 1800)
-  message(FATAL_ERROR "Building with Microsoft compiler needs Visual Studio 2013 or later (Express version works too)")
-endif()
-
-option(ENABLE_JSON_LOGGING "Adds additional JSON debug logging to the response" OFF)
-option(DEBUG_GEOMETRY "Enables an option to dump GeoJSON of the final routing graph" OFF)
-option(BUILD_TOOLS "Build OSRM tools" OFF)
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR})
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include/)
-
-add_custom_target(FingerPrintConfigure ALL ${CMAKE_COMMAND}
-  "-DOUTPUT_DIR=${CMAKE_CURRENT_BINARY_DIR}"
-  "-DSOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}"
-  -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/FingerPrint-Config.cmake"
-  COMMENT "Configuring revision fingerprint"
-  VERBATIM)
-
-add_custom_target(tests DEPENDS datastructure-tests algorithm-tests util-tests)
-add_custom_target(benchmarks DEPENDS rtree-bench)
-
-set(BOOST_COMPONENTS date_time filesystem iostreams program_options regex system thread unit_test_framework)
-
-configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/util/version.hpp.in
-  ${CMAKE_CURRENT_BINARY_DIR}/util/version.hpp
-)
-file(GLOB ExtractorGlob extractor/*.cpp data_structures/hilbert_value.cpp)
-file(GLOB ImporterGlob data_structures/import_edge.cpp data_structures/external_memory_node.cpp data_structures/raster_source.cpp)
-add_library(IMPORT OBJECT ${ImporterGlob})
-add_library(LOGGER OBJECT util/simple_logger.cpp)
-add_library(PHANTOMNODE OBJECT data_structures/phantom_node.cpp)
-add_library(RASTERSOURCE OBJECT data_structures/raster_source.cpp)
-add_library(EXCEPTION OBJECT util/osrm_exception.cpp)
-add_library(MERCATOR OBJECT util/mercator.cpp)
-add_library(ANGLE OBJECT util/compute_angle.cpp)
-
-set(ExtractorSources extract.cpp ${ExtractorGlob})
-add_executable(osrm-extract ${ExtractorSources} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:ANGLE>)
-
-add_library(RESTRICTION OBJECT data_structures/restriction_map.cpp)
-add_library(COMPRESSEDEDGE OBJECT data_structures/compressed_edge_container.cpp)
-add_library(GRAPHCOMPRESSOR OBJECT algorithms/graph_compressor.cpp)
-
-file(GLOB PrepareGlob contractor/*.cpp data_structures/hilbert_value.cpp {RestrictionMapGlob})
-set(PrepareSources prepare.cpp ${PrepareGlob})
-add_executable(osrm-prepare ${PrepareSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR>)
-
-file(GLOB ServerGlob server/*.cpp)
-file(GLOB DescriptorGlob descriptors/*.cpp)
-file(GLOB DatastructureGlob data_structures/search_engine_data.cpp data_structures/route_parameters.cpp util/bearing.cpp)
-file(GLOB CoordinateGlob data_structures/coordinate.cpp algorithms/coordinate_calculation.cpp)
-file(GLOB AlgorithmGlob algorithms/polyline_compressor.cpp algorithms/polyline_formatter.cpp algorithms/douglas_peucker.cpp)
-file(GLOB HttpGlob server/http/*.cpp)
-file(GLOB LibOSRMGlob library/*.cpp)
-file(GLOB DataStructureTestsGlob unit_tests/data_structures/*.cpp data_structures/hilbert_value.cpp)
-file(GLOB AlgorithmTestsGlob unit_tests/algorithms/*.cpp algorithms/graph_compressor.cpp)
-file(GLOB UtilTestsGlob unit_tests/util/*.cpp)
-
-set(
-  OSRMSources
-  ${LibOSRMGlob}
-  ${DescriptorGlob}
-  ${DatastructureGlob}
-  ${AlgorithmGlob}
-  ${HttpGlob}
-)
-
-add_library(COORDINATE OBJECT ${CoordinateGlob})
-add_library(OSRM ${OSRMSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:IMPORT>)
-
-add_library(FINGERPRINT OBJECT util/fingerprint.cpp)
-add_dependencies(FINGERPRINT FingerPrintConfigure)
-add_dependencies(OSRM FingerPrintConfigure)
-set_target_properties(FINGERPRINT PROPERTIES LINKER_LANGUAGE CXX)
-
-add_executable(osrm-routed routed.cpp ${ServerGlob} $<TARGET_OBJECTS:EXCEPTION>)
-add_executable(osrm-datastore datastore.cpp $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
-
-# Unit tests
-add_executable(datastructure-tests EXCLUDE_FROM_ALL unit_tests/datastructure_tests.cpp ${DataStructureTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:RASTERSOURCE>)
-add_executable(algorithm-tests EXCLUDE_FROM_ALL unit_tests/algorithm_tests.cpp ${AlgorithmTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:COMPRESSEDEDGE>)
-add_executable(util-tests EXCLUDE_FROM_ALL unit_tests/util_tests.cpp ${UtilTestsGlob})
-
-# Benchmarks
-add_executable(rtree-bench EXCLUDE_FROM_ALL benchmarks/static_rtree.cpp $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
-
-# Check the release mode
-if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
-  set(CMAKE_BUILD_TYPE Release)
-endif()
-if(CMAKE_BUILD_TYPE MATCHES Debug)
-  message(STATUS "Configuring OSRM in debug mode")
-  if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
-
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-inline -fno-omit-frame-pointer")
-
-  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Og -ggdb")
-  endif()
-
-  endif()
-endif()
-if(CMAKE_BUILD_TYPE MATCHES Release)
-  message(STATUS "Configuring OSRM in release mode")
-  # Check if LTO is available
-  check_cxx_compiler_flag("-flto" LTO_AVAILABLE)
-  if(LTO_AVAILABLE)
-    set(OLD_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-    # GCC in addition allows parallelizing LTO
-    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-      include(ProcessorCount)
-      ProcessorCount(NPROC)
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto=${NPROC}")
-    else()
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
-    endif()
-    set(CHECK_LTO_SRC "int main(){return 0;}")
-    check_cxx_source_compiles("${CHECK_LTO_SRC}" LTO_WORKS)
-    if(LTO_WORKS)
-      message(STATUS "LTO working")
-    else()
-      message(STATUS "LTO broken")
-      set(CMAKE_CXX_FLAGS "${OLD_CXX_FLAGS}")
-    endif()
-
-    # Since gcc 4.9 the LTO format is non-standart ('slim'), so we need to use the build-in tools
-    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND
-        NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9.0" AND NOT MINGW)
-      message(STATUS "Using gcc specific binutils for LTO.")
-      set(CMAKE_AR     "/usr/bin/gcc-ar")
-      set(CMAKE_RANLIB "/usr/bin/gcc-ranlib")
-    endif()
-
-    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9.0")
-      message(STATUS "Disabling LTO on GCC < 4.9.0 since it is broken, see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57038")
-      set(CMAKE_CXX_FLAGS "${OLD_CXX_FLAGS}")
-    endif()
-  endif()
-endif()
-
-if(NOT WIN32)
-  add_definitions(-DBOOST_TEST_DYN_LINK)
-endif()
-
-# Configuring compilers
-if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=2 -D_FORTIFY_SOURCE=2 -fPIC")
-elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
-  set(COLOR_FLAG "-fdiagnostics-color=auto")
-  check_cxx_compiler_flag("-fdiagnostics-color=auto" HAS_COLOR_FLAG)
-  if(NOT HAS_COLOR_FLAG)
-    set(COLOR_FLAG "")
-  endif()
-  # using GCC
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=1 -D_FORTIFY_SOURCE=2 ${COLOR_FLAG} -fPIC")
-  if(WIN32) # using mingw
-    add_definitions(-D_USE_MATH_DEFINES) # define M_PI, M_1_PI etc.
-    add_definitions(-DWIN32)
-    set(OPTIONAL_SOCKET_LIBS ws2_32 wsock32)
-  endif()
-elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "Intel")
-  # using Intel C++
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-intel -wd10237 -Wall -ipo -fPIC")
-elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
-  # using Visual Studio C++
-  set(BOOST_COMPONENTS ${BOOST_COMPONENTS} date_time chrono zlib)
-  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-  add_definitions(-DNOMINMAX) # avoid min and max macros that can break compilation
-  add_definitions(-D_USE_MATH_DEFINES) # define M_PI
-  add_definitions(-D_WIN32_WINNT=0x0501)
-  add_definitions(-DXML_STATIC)
-  find_library(ws2_32_LIBRARY_PATH ws2_32)
-  target_link_libraries(osrm-extract wsock32 ws2_32)
-endif()
-
-# Configuring linker
-execute_process(COMMAND ${CMAKE_CXX_COMPILER} "-Wl,--version" ERROR_QUIET OUTPUT_VARIABLE LINKER_VERSION)
-# For ld.gold and ld.bfs (the GNU linkers) we optimize hard
-if("${LINKER_VERSION}" MATCHES "GNU gold" OR "${LINKER_VERSION}" MATCHES "GNU ld")
-  message(STATUS "Setting linker optimizations")
-  if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
-    # Tell compiler to put every function in separate section, linker can then match sections and functions
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffunction-sections -fdata-sections")
-    # Tell linker to do dead code and data eminination during link time discarding sections
-    set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,--gc-sections")
-  endif()
-  # Default linker optimization flags
-  set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,-O1 -Wl,--hash-style=gnu -Wl,--sort-common")
-else()
-  message(STATUS "Using unknown linker, not setting linker optimizations")
-endif ()
-set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
-set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
-
-# Activate C++11
-if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 ")
-endif()
-
-# Configuring other platform dependencies
-if(APPLE)
-  set(CMAKE_OSX_ARCHITECTURES "x86_64")
-  message(STATUS "Set Architecture to x64 on OS X")
-  exec_program(uname ARGS -v  OUTPUT_VARIABLE DARWIN_VERSION)
-  string(REGEX MATCH "[0-9]+" DARWIN_VERSION ${DARWIN_VERSION})
-  if(OSXLIBSTD)
-    message(STATUS "linking against ${OSXLIBSTD}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=${OSXLIBSTD}")
-  elseif(DARWIN_VERSION GREATER 12)
-    message(STATUS "linking against libc++")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
-  endif()
-endif()
-
-if(UNIX AND NOT APPLE)
-  target_link_libraries(osrm-prepare rt)
-  target_link_libraries(osrm-datastore rt)
-  target_link_libraries(OSRM rt)
-endif()
-
-#Check Boost
-find_package(Boost 1.49.0 COMPONENTS ${BOOST_COMPONENTS} REQUIRED)
-if(NOT Boost_FOUND)
-  message(FATAL_ERROR "Fatal error: Boost (version >= 1.49.0) required.\n")
-endif()
-include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
-
-target_link_libraries(OSRM ${Boost_LIBRARIES})
-target_link_libraries(osrm-extract ${Boost_LIBRARIES})
-target_link_libraries(osrm-prepare ${Boost_LIBRARIES})
-target_link_libraries(osrm-routed ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM)
-target_link_libraries(osrm-datastore ${Boost_LIBRARIES})
-target_link_libraries(datastructure-tests ${Boost_LIBRARIES})
-target_link_libraries(algorithm-tests ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM)
-target_link_libraries(util-tests ${Boost_LIBRARIES})
-target_link_libraries(rtree-bench ${Boost_LIBRARIES})
-
-find_package(Threads REQUIRED)
-target_link_libraries(osrm-extract ${CMAKE_THREAD_LIBS_INIT})
-target_link_libraries(osrm-datastore ${CMAKE_THREAD_LIBS_INIT})
-target_link_libraries(osrm-prepare ${CMAKE_THREAD_LIBS_INIT})
-target_link_libraries(OSRM ${CMAKE_THREAD_LIBS_INIT})
-target_link_libraries(datastructure-tests ${CMAKE_THREAD_LIBS_INIT})
-target_link_libraries(algorithm-tests ${CMAKE_THREAD_LIBS_INIT})
-target_link_libraries(rtree-bench ${CMAKE_THREAD_LIBS_INIT})
-
-find_package(TBB REQUIRED)
-if(WIN32 AND CMAKE_BUILD_TYPE MATCHES Debug)
-  set(TBB_LIBRARIES ${TBB_DEBUG_LIBRARIES})
-endif()
-target_link_libraries(osrm-datastore ${TBB_LIBRARIES})
-target_link_libraries(osrm-extract ${TBB_LIBRARIES})
-target_link_libraries(osrm-prepare ${TBB_LIBRARIES})
-target_link_libraries(osrm-routed ${TBB_LIBRARIES})
-target_link_libraries(datastructure-tests ${TBB_LIBRARIES})
-target_link_libraries(algorithm-tests ${TBB_LIBRARIES})
-target_link_libraries(rtree-bench ${TBB_LIBRARIES})
-include_directories(SYSTEM ${TBB_INCLUDE_DIR})
-
-find_package( Luabind REQUIRED )
-include(check_luabind)
-
-include_directories(SYSTEM ${LUABIND_INCLUDE_DIR})
-target_link_libraries(osrm-extract ${LUABIND_LIBRARY})
-target_link_libraries(osrm-prepare ${LUABIND_LIBRARY})
-
-if(LUAJIT_FOUND)
-  target_link_libraries(osrm-extract ${LUAJIT_LIBRARIES})
-  target_link_libraries(osrm-prepare ${LUAJIT_LIBRARIES})
-else()
-  target_link_libraries(osrm-extract ${LUA_LIBRARY})
-  target_link_libraries(osrm-prepare ${LUA_LIBRARY})
-endif()
-include_directories(SYSTEM ${LUA_INCLUDE_DIR})
-
-find_package(EXPAT REQUIRED)
-include_directories(SYSTEM ${EXPAT_INCLUDE_DIRS})
-target_link_libraries(osrm-extract ${EXPAT_LIBRARIES})
-
-find_package(STXXL REQUIRED)
-include_directories(SYSTEM ${STXXL_INCLUDE_DIR})
-target_link_libraries(OSRM ${STXXL_LIBRARY})
-target_link_libraries(osrm-extract ${STXXL_LIBRARY})
-target_link_libraries(osrm-prepare ${STXXL_LIBRARY})
-target_link_libraries(datastructure-tests ${STXXL_LIBRARY})
-
-set(OpenMP_FIND_QUIETLY ON)
-find_package(OpenMP)
-if(OPENMP_FOUND)
-  message(STATUS "OpenMP support found. Linking just in case for stxxl")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
-endif()
-
-find_package(BZip2 REQUIRED)
-include_directories(SYSTEM ${BZIP_INCLUDE_DIRS})
-target_link_libraries(osrm-extract ${BZIP2_LIBRARIES})
-
-find_package(ZLIB REQUIRED)
-include_directories(SYSTEM ${ZLIB_INCLUDE_DIRS})
-target_link_libraries(osrm-extract ${ZLIB_LIBRARY})
-target_link_libraries(osrm-routed ${ZLIB_LIBRARY})
-
-if (ENABLE_JSON_LOGGING)
-  message(STATUS "Enabling json logging")
-  add_definitions(-DENABLE_JSON_LOGGING)
-endif()
-
-if (DEBUG_GEOMETRY)
-  message(STATUS "Enabling final edge weight GeoJSON output option")
-  add_definitions(-DDEBUG_GEOMETRY)
-endif()
-
-if(BUILD_TOOLS)
-  message(STATUS "Activating OSRM internal tools")
-  find_package(GDAL)
-  if(GDAL_FOUND)
-    add_executable(osrm-components tools/components.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
-    target_link_libraries(osrm-components ${TBB_LIBRARIES})
-    include_directories(SYSTEM ${GDAL_INCLUDE_DIR})
-    target_link_libraries(osrm-components ${GDAL_LIBRARIES} ${Boost_LIBRARIES})
-    install(TARGETS osrm-components DESTINATION bin)
-  else()
-    message(FATAL_ERROR "libgdal and/or development headers not found")
-  endif()
-  add_executable(osrm-cli tools/simpleclient.cpp $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:COORDINATE>)
-  target_link_libraries(osrm-cli ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM)
-  target_link_libraries(osrm-cli ${TBB_LIBRARIES})
-  add_executable(osrm-io-benchmark tools/io-benchmark.cpp $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER>)
-  target_link_libraries(osrm-io-benchmark ${Boost_LIBRARIES})
-  add_executable(osrm-unlock-all tools/unlock_all_mutexes.cpp $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION>)
-  target_link_libraries(osrm-unlock-all ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
-  if(UNIX AND NOT APPLE)
-    target_link_libraries(osrm-unlock-all rt)
-  endif()
-  add_executable(osrm-check-hsgr tools/check-hsgr.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:IMPORT>)
-  target_link_libraries(osrm-check-hsgr ${Boost_LIBRARIES} ${TBB_LIBRARIES})
-  add_executable(osrm-springclean tools/springclean.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION>)
-  target_link_libraries(osrm-springclean ${Boost_LIBRARIES})
-
-  install(TARGETS osrm-cli DESTINATION bin)
-  install(TARGETS osrm-io-benchmark DESTINATION bin)
-  install(TARGETS osrm-unlock-all DESTINATION bin)
-  install(TARGETS osrm-check-hsgr DESTINATION bin)
-  install(TARGETS osrm-springclean DESTINATION bin)
-endif()
-
-file(GLOB InstallGlob include/osrm/*.hpp)
-file(GLOB VariantGlob third_party/variant/*.hpp)
-
-# Add RPATH info to executables so that when they are run after being installed
-# (i.e., from /usr/local/bin/) the linker can find library dependencies. For
-# more info see http://www.cmake.org/Wiki/CMake_RPATH_handling
-set_property(TARGET osrm-extract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-set_property(TARGET osrm-prepare PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-set_property(TARGET osrm-datastore PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-
-install(FILES ${InstallGlob} DESTINATION include/osrm)
-install(FILES ${VariantGlob} DESTINATION include/variant)
-install(TARGETS osrm-extract DESTINATION bin)
-install(TARGETS osrm-prepare DESTINATION bin)
-install(TARGETS osrm-datastore DESTINATION bin)
-install(TARGETS osrm-routed DESTINATION bin)
-install(TARGETS OSRM DESTINATION lib)
-
-list(GET Boost_LIBRARIES 1 BOOST_LIBRARY_FIRST)
-get_filename_component(BOOST_LIBRARY_LISTING "${BOOST_LIBRARY_FIRST}" PATH)
-set(BOOST_LIBRARY_LISTING "-L${BOOST_LIBRARY_LISTING}")
-foreach(lib ${Boost_LIBRARIES})
-  get_filename_component(BOOST_LIBRARY_NAME "${lib}" NAME_WE)
-  string(REPLACE "lib" "" BOOST_LIBRARY_NAME ${BOOST_LIBRARY_NAME})
-  set(BOOST_LIBRARY_LISTING "${BOOST_LIBRARY_LISTING} -l${BOOST_LIBRARY_NAME}")
-endforeach()
-list(GET TBB_LIBRARIES 1 TBB_LIBRARY_FIRST)
-get_filename_component(TBB_LIBRARY_LISTING "${TBB_LIBRARY_FIRST}" PATH)
-set(TBB_LIBRARY_LISTING "-L${TBB_LIBRARY_LISTING}")
-foreach(lib ${TBB_LIBRARIES})
-  get_filename_component(TBB_LIBRARY_NAME "${lib}" NAME_WE)
-  string(REPLACE "lib" "" TBB_LIBRARY_NAME ${TBB_LIBRARY_NAME})
-  set(TBB_LIBRARY_LISTING "${TBB_LIBRARY_LISTING} -l${TBB_LIBRARY_NAME}")
-endforeach()
-
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in libosrm.pc @ONLY)
-install(FILES ${PROJECT_BINARY_DIR}/libosrm.pc DESTINATION lib/pkgconfig)
-
-if(BUILD_DEBIAN_PACKAGE)
-  include(CPackDebianConfig)
-  include(CPack)
-endif()
-
-# add a target to generate API documentation with Doxygen
-find_package(Doxygen)
-if(DOXYGEN_FOUND)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
-add_custom_target(doc
-${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
-WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-COMMENT "Generating API documentation with Doxygen" VERBATIM
-)
-endif()
-
-# prefix compilation with ccache by default if available and on clang or gcc
-if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
-  find_program(CCACHE_FOUND ccache)
-  if(CCACHE_FOUND)
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
-    set(ENV{CCACHE_CPP2} "true")
-  endif()
-endif()

Doxyfile.in

@@ -1,43 +0,0 @@
-PROJECT_NAME           = "Project OSRM"
-PROJECT_BRIEF          = "Open Source Routing Machine"
-BUILTIN_STL_SUPPORT    = YES
-
-EXTRACT_ALL            = YES
-EXTRACT_PRIVATE        = YES
-EXTRACT_PACKAGE        = YES
-EXTRACT_STATIC         = YES
-EXTRACT_LOCAL_CLASSES  = YES
-EXTRACT_ANON_NSPACES   = YES
-
-QUIET                  = YES
-
-INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@
-USE_MDFILE_AS_MAINPAGE = @CMAKE_CURRENT_SOURCE_DIR@/README.md
-FILE_PATTERNS          = *.h *.hpp *.c *.cc *.cpp *.md
-RECURSIVE              = YES
-
-EXCLUDE                = @CMAKE_CURRENT_SOURCE_DIR@/third_party \
-                         @CMAKE_CURRENT_SOURCE_DIR@/build \
-                         @CMAKE_CURRENT_SOURCE_DIR@/unit_tests \
-			 @CMAKE_CURRENT_SOURCE_DIR@/benchmarks \
-                         @CMAKE_CURRENT_SOURCE_DIR@/features
-
-SOURCE_BROWSER         = YES
-
-CLANG_ASSISTED_PARSING = NO
-
-HTML_COLORSTYLE_HUE    = 217
-HTML_COLORSTYLE_SAT    = 71
-HTML_COLORSTYLE_GAMMA  = 50
-
-GENERATE_TREEVIEW      = YES
-
-HAVE_DOT               = @DOXYGEN_DOT_FOUND@
-CALL_GRAPH             = YES
-CALLER_GRAPH           = YES
-
-DOT_IMAGE_FORMAT       = svg
-INTERACTIVE_SVG        = YES
-DOT_GRAPH_MAX_NODES    = 500
-DOT_TRANSPARENT        = YES
-DOT_MULTI_TARGETS      = YES

Gemfile

@@ -1,7 +0,0 @@
-source "http://rubygems.org"
-
-gem "cucumber"
-gem "rake"
-gem "osmlib-base"
-gem "sys-proctable"
-gem "rspec-expectations"

Gemfile.lock

@@ -1,35 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    builder (3.2.2)
-    cucumber (2.0.0)
-      builder (>= 2.1.2)
-      cucumber-core (~> 1.1.3)
-      diff-lcs (>= 1.1.3)
-      gherkin (~> 2.12)
-      multi_json (>= 1.7.5, < 2.0)
-      multi_test (>= 0.1.2)
-    cucumber-core (1.1.3)
-      gherkin (~> 2.12.0)
-    diff-lcs (1.2.5)
-    gherkin (2.12.2)
-      multi_json (~> 1.3)
-    multi_json (1.11.0)
-    multi_test (0.1.2)
-    osmlib-base (0.1.4)
-    rake (10.4.2)
-    rspec-expectations (3.2.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-support (3.2.2)
-    sys-proctable (0.9.8)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  cucumber
-  osmlib-base
-  rake
-  rspec-expectations
-  sys-proctable

LICENCE.TXT

@@ -1,22 +0,0 @@
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -1,46 +1,54 @@
-## About
+Overview
+--------
+The repository provides a Leaflet [(1)] based web frontend to the Open Source Routing Machine (Project-OSRM [(2)]).
+The frontend is implemented in Javascript.
+Data is fetched from routing and geocoding servers using JSONP queries.
+The website is XHTML 1.0 Strict compliant.
+A deployed version of the the web frontend can be seen at [(3)].
 
-The Open Source Routing Machine is a high performance routing engine written in C++11 designed to run on OpenStreetMap data.
 
-## Current build status
+Setup
+-----
+The frontend should work directly as provided.
+Several settings - including the URL for the routing server and the geocoder server - can be specified in `OSRM.config.js`.
+Different tile servers can be specified in `OSRM.Map.js`.
+Note that the URL shortener used for generating route links only works with URLs pointing to the official Project-OSRM website.
 
-| build config |  branch | status |
-|:-------------|:--------|:------------|
-| Linux        | master  | [![Build Status](https://travis-ci.org/Project-OSRM/osrm-backend.png?branch=master)](https://travis-ci.org/Project-OSRM/osrm-backend) |
-| Linux        | develop | [![Build Status](https://travis-ci.org/Project-OSRM/osrm-backend.png?branch=develop)](https://travis-ci.org/Project-OSRM/osrm-backend) |
-| Windows      | master/develop | [![Build status](https://ci.appveyor.com/api/projects/status/4iuo3s9gxprmcjjh)](https://ci.appveyor.com/project/DennisOSRM/osrm-backend) |
-| LUAbind fork | master  | [![Build Status](https://travis-ci.org/DennisOSRM/luabind.png?branch=master)](https://travis-ci.org/DennisOSRM/luabind) |
 
-## Building
+Branches
+--------
+* The `master` branch will always point to the latest released version of the frontend.
+* The `develop` branch should always point to a working version with new features and bugfixes (think of it as a nightly-build).
+* Other branches contain various work in progress.
 
-For instructions on how to [build](https://github.com/Project-OSRM/osrm-backend/wiki/Building-OSRM) and [run OSRM](https://github.com/Project-OSRM/osrm-backend/wiki/Running-OSRM), please consult [the Wiki](https://github.com/Project-OSRM/osrm-backend/wiki).
 
-To quickly try OSRM use our [free and daily updated online service](http://map.project-osrm.org)
+Bugtracking
+-----------
+Please use the OSRM-Project bug tracker for submitting any bug reports or feature requests.
 
-## Documentation
+Integration into Project-OSRM repository
+----------------------------------------
+The Project-OSRM repository already contains the frontend repository as a submodule.
+It will always point to the latest deployed version.
+To successfully work a repository that contains submodules, use the following git commands (available in git 1.7.1+):
 
-See the Wiki's [server API documentation](https://github.com/Project-OSRM/osrm-backend/wiki/Server-api) as well as the [library API documentation](https://github.com/Project-OSRM/osrm-backend/wiki/Library-api)
+* `git clone --recursive`  
+	to clone a repository and the contained submodules
 
-## References in publications
+* `git pull && git submodule update`  
+	to pull the latest version of the repository and update its submodules if required
 
-When using the code in a (scientific) publication, please cite
+Note that the frontend can also be checked out independently of the Project-OSRM repository.
 
-```
-@inproceedings{luxen-vetter-2011,
- author = {Luxen, Dennis and Vetter, Christian},
- title = {Real-time routing with OpenStreetMap data},
- booktitle = {Proceedings of the 19th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems},
- series = {GIS '11},
- year = {2011},
- isbn = {978-1-4503-1031-4},
- location = {Chicago, Illinois},
- pages = {513--516},
- numpages = {4},
- url = {http://doi.acm.org/10.1145/2093973.2094062},
- doi = {10.1145/2093973.2094062},
- acmid = {2094062},
- publisher = {ACM},
- address = {New York, NY, USA},
-}
-```
 
+References
+----------
+[(1)] Cloudmade Leaflet: http://leaflet.cloudmade.com/  
+[(2)] Project OSRM: http://project-osrm.org/  
+[(3)] Project OSRM Frontend: http://map.project-osrm.org/
+
+
+
+[(1)]: http://leaflet.cloudmade.com/ "Cloudmade Leaflet"
+[(2)]: http://project-osrm.org/ "Project OSRM"
+[(3)]: http://map.project-osrm.org/ "Project-OSRM Frontend" 

Rakefile

@@ -1,190 +0,0 @@
-require 'OSM/StreamParser'
-require 'socket'
-require 'digest/sha1'
-require 'cucumber/rake/task'
-require 'sys/proctable'
-
-BUILD_FOLDER = 'build'
-DATA_FOLDER = 'sandbox'
-PROFILE = 'bicycle'
-OSRM_PORT = 5000
-PROFILES_FOLDER = '../profiles'
-
-Cucumber::Rake::Task.new do |t|
-  t.cucumber_opts = %w{--format pretty}
-end
-
-areas = {
-  :kbh => { :country => 'denmark', :bbox => 'top=55.6972 left=12.5222 right=12.624 bottom=55.6376' },
-  :frd => { :country => 'denmark', :bbox => 'top=55.7007 left=12.4765 bottom=55.6576 right=12.5698' },
-  :regh => { :country => 'denmark', :bbox => 'top=56.164 left=11.792 bottom=55.403 right=12.731' },
-  :denmark => { :country => 'denmark', :bbox => nil },
-  :skaane => { :country => 'sweden', :bbox => 'top=56.55 left=12.4 bottom=55.3 right=14.6' }
-}
-
-
-
-osm_data_area_name = ARGV[1] ? ARGV[1].to_s.to_sym : :kbh
-raise "Unknown data area." unless areas[osm_data_area_name]
-osm_data_country = areas[osm_data_area_name][:country]
-osm_data_area_bbox = areas[osm_data_area_name][:bbox]
-
-
-task osm_data_area_name.to_sym {}   #define empty task to prevent rake from whining. will break if area has same name as a task
-
-
-def each_process name, &block
-  Sys::ProcTable.ps do |process|
-    if process.comm.strip == name.strip && process.state != 'zombie'
-      yield process.pid.to_i, process.state.strip
-    end
-  end
-end
-
-def up?
-  find_pid('osrm-routed') != nil
-end
-
-def find_pid name
-  each_process(name) { |pid,state| return pid.to_i }
-  return nil
-end
-
-def wait_for_shutdown name
-  timeout = 10
-  (timeout*10).times do
-    return if find_pid(name) == nil
-    sleep 0.1
-  end
-  raise "*** Could not terminate #{name}."
-end
-
-
-desc "Rebuild and run tests."
-task :default => [:build]
-
-desc "Build using CMake."
-task :build do
-  if Dir.exists? BUILD_FOLDER
-    Dir.chdir BUILD_FOLDER do
-      system "make"
-    end
-  else
-    system "mkdir build; cd build; cmake ..; make"
-  end
-end
-
-desc "Setup config files."
-task :setup do
-end
-
-desc "Download OSM data."
-task :download do
-  Dir.mkdir "#{DATA_FOLDER}" unless File.exist? "#{DATA_FOLDER}"
-  puts "Downloading..."
-  puts "curl http://download.geofabrik.de/europe/#{osm_data_country}-latest.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
-  raise "Error while downloading data." unless system "curl http://download.geofabrik.de/europe/#{osm_data_country}-latest.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
-  if osm_data_area_bbox
-    puts "Cropping and converting to protobuffer..."
-    raise "Error while cropping data." unless system "osmosis --read-pbf file=#{DATA_FOLDER}/#{osm_data_country}.osm.pbf --bounding-box #{osm_data_area_bbox} --write-pbf file=#{DATA_FOLDER}/#{osm_data_area_name}.osm.pbf omitmetadata=true"
-  end
-end
-
-desc "Crop OSM data"
-task :crop do
-  if osm_data_area_bbox
-    raise "Error while cropping data." unless system "osmosis --read-pbf file=#{DATA_FOLDER}/#{osm_data_country}.osm.pbf --bounding-box #{osm_data_area_bbox} --write-pbf file=#{DATA_FOLDER}/#{osm_data_area_name}.osm.pbf omitmetadata=true"
-  end
-end
-
-desc "Reprocess OSM data."
-task :process => [:extract,:prepare] do
-end
-
-desc "Extract OSM data."
-task :extract do
-  Dir.chdir DATA_FOLDER do
-    raise "Error while extracting data." unless system "../#{BUILD_FOLDER}/osrm-extract #{osm_data_area_name}.osm.pbf --profile ../profiles/#{PROFILE}.lua"
-  end
-end
-
-desc "Prepare OSM data."
-task :prepare do
-  Dir.chdir DATA_FOLDER do
-    raise "Error while preparing data." unless system "../#{BUILD_FOLDER}/osrm-prepare #{osm_data_area_name}.osrm --profile ../profiles/#{PROFILE}.lua"
-  end
-end
-
-desc "Delete preprocessing files."
-task :clean do
-  File.delete *Dir.glob("#{DATA_FOLDER}/*.osrm")
-  File.delete *Dir.glob("#{DATA_FOLDER}/*.osrm.*")
-end
-
-desc "Run all cucumber test"
-task :test do
-  system "cucumber"
-  puts
-end
-
-desc "Run the routing server in the terminal. Press Ctrl-C to stop."
-task :run do
-  Dir.chdir DATA_FOLDER do
-    system "../#{BUILD_FOLDER}/osrm-routed #{osm_data_area_name}.osrm --port #{OSRM_PORT}"
-  end
-end
-
-desc "Launch the routing server in the background. Use rake:down to stop it."
-task :up do
-  Dir.chdir DATA_FOLDER do
-    abort("Already up.") if up?
-    pipe = IO.popen("../#{BUILD_FOLDER}/osrm-routed #{osm_data_area_name}.osrm --port #{OSRM_PORT} 1>>osrm-routed.log 2>>osrm-routed.log")
-    timeout = 5
-    (timeout*10).times do
-      begin
-        socket = TCPSocket.new('localhost', OSRM_PORT)
-        socket.puts 'ping'
-      rescue Errno::ECONNREFUSED
-        sleep 0.1
-      end
-    end
-  end
-end
-
-desc "Stop the routing server."
-task :down do
-  pid = find_pid 'osrm-routed'
-  if pid
-    Process.kill 'TERM', pid
-  else
-    puts "Already down."
-  end 
-end
-
-desc "Kill all osrm-extract, osrm-prepare and osrm-routed processes."
-task :kill do
-  each_process('osrm-routed') { |pid,state| Process.kill 'KILL', pid }
-  each_process('osrm-prepare') { |pid,state| Process.kill 'KILL', pid }
-  each_process('osrm-extract') { |pid,state| Process.kill 'KILL', pid }
-  wait_for_shutdown 'osrm-routed'
-  wait_for_shutdown 'osrm-prepare'
-  wait_for_shutdown 'osrm-extract'  
-end
-
-desc "Get PIDs of all osrm-extract, osrm-prepare and osrm-routed processes."
-task :pid do
-  each_process 'osrm-routed' do |pid,state|
-    puts "#{pid}\t#{state}"
-  end
-end
-
-desc "Stop, reprocess and restart."
-task :update => [:down,:process,:up] do
-end
-
-
-desc "Remove test cache files."
-task :sweep do
-  system "rm test/cache/*"
-end
-

WebContent/L.Bugfixes.js

@@ -0,0 +1,80 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// Leaflet bugfixes
+// [assorted bugfixes to Leaflet functions we use]
+
+
+// return closest point on segment or distance to that point
+L.LineUtil._sqClosestPointOnSegment = function (p, p1, p2, sqDist) {
+	var x = p1.x,
+		y = p1.y,
+		dx = p2.x - x,
+		dy = p2.y - y,
+		dot = dx * dx + dy * dy,
+		t;
+
+	if (dot > 0) {
+		t = ((p.x - x) * dx + (p.y - y) * dy) / dot;
+
+		if (t > 1) {
+			x = p2.x;
+			y = p2.y;
+		} else if (t > 0) {
+			x += dx * t;
+			y += dy * t;
+		}
+	}
+
+	dx = p.x - x;
+	dy = p.y - y;
+		
+	// DS_CHANGE: modified return values
+	if(sqDist)
+		return dx*dx + dy*dy;
+	else {
+		var p = new L.Point(x,y);
+		p._sqDist = dx*dx + dy*dy;
+		return p;
+	}
+};
+
+
+// makes requestAnimFrame respect the immediate paramter -> prevents drag events after dragend events
+// (alternatively: add if(!this.dragging ) return to L.Draggable._updatePosition, but must be done in leaflet.js!)
+// [TODO: In Leaflet 0.4 use L.Util.cancelAnimFrame(this._animRequest) in L.Draggable._onUp() instead, also has to be done in leaflet.js!]
+L.Util.requestAnimFrame = (function () {
+	function timeoutDefer(callback) {
+		window.setTimeout(callback, 1000 / 60);
+	}
+
+	var requestFn = window.requestAnimationFrame ||
+		window.webkitRequestAnimationFrame ||
+		window.mozRequestAnimationFrame ||
+		window.oRequestAnimationFrame ||
+		window.msRequestAnimationFrame ||
+		timeoutDefer;
+
+	return function (callback, context, immediate, contextEl) {
+		callback = context ? L.Util.bind(callback, context) : callback;
+		if (immediate ) {		// DS_CHANGE: removed additional condition requestFn === timeoutDefer
+			callback();
+		} else {
+			requestFn(callback, contextEl);
+		}
+	};
+}());	

WebContent/L.DashedPolyline.js

@@ -0,0 +1,60 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// Leaflet extension: Dashed Polyline
+// [adds dashed optionally dashed lines when using SVG or VML rendering]
+
+
+// dashed polyline class
+L.DashedPolyline = L.Polyline.extend({
+	initialize: function(latlngs, options) {
+		L.Polyline.prototype.initialize.call(this, latlngs, options);
+	},
+	
+	options: {
+		dashed: true
+	}
+});
+
+
+// svg rendering
+L.DashedPolyline = !L.Browser.svg ? L.DashedPolyline : L.DashedPolyline.extend({
+	_updateStyle: function () {
+		L.Polyline.prototype._updateStyle.call(this);
+		if (this.options.stroke) {
+			if (this.options.dashed == true)
+				this._path.setAttribute('stroke-dasharray', '8,6');
+			else
+				this._path.setAttribute('stroke-dasharray', '');
+		}
+	}
+});
+
+
+// vml rendering
+L.DashedPolyline = L.Browser.svg || !L.Browser.vml ? L.DashedPolyline : L.DashedPolyline.extend({
+	_updateStyle: function () {
+		L.Polyline.prototype._updateStyle.call(this);
+		if (this.options.stroke) {
+			if (this.options.dashed == true)
+				this._stroke.dashstyle = "dash";
+			else
+				this._stroke.dashstyle = "solid";
+		}
+	}
+	
+});

WebContent/L.MouseMarker.js

@@ -0,0 +1,64 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// Leaflet extension: MouseMarker
+// [marker class that propagates modifier and button presses in mouse click events and allows for changing icons]
+
+
+// extended marker class
+L.MouseMarker = L.Marker.extend({
+	initialize: function (latlng, options) {
+		L.Marker.prototype.initialize.apply(this, arguments);
+	},
+	
+	switchIcon: function( icon ) {
+		this.options.icon = icon;
+
+		if (this._map) {
+			this._changeIcon();
+			this._reset();
+		}
+	},
+	
+	_changeIcon: function () {
+		var options = this.options;
+
+		if (this._icon) {
+			this._icon = options.icon.switchIcon( this._icon );
+			this._icon.title = options.title;
+		}
+		
+		var panes = this._map._panes;
+		
+		if (this._shadow)
+			panes.shadowPane.removeChild(this._shadow);
+		this._shadow = options.icon.createShadow();
+		if (this._shadow)
+			panes.shadowPane.appendChild(this._shadow);
+	},	
+
+	_onMouseClick: function (e) {
+		L.DomEvent.stopPropagation(e);
+		if (this.dragging && this.dragging.moved()) { return; }
+		this.fire(e.type, {
+			altKey: e.altKey,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			button: e.button
+		});
+	}
+});

WebContent/L.SwitchableIcon.js

@@ -0,0 +1,115 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// Leaflet extension: SwitchableIcon
+// [will be an extension of L.Icon in Leaflet 0.4, for now it is a copy with added functionality]
+
+
+// icon class with functions to simply switch the icon images
+L.SwitchableIcon = L.Class.extend({
+	options: {
+		/*
+		iconUrl: (String) (required)
+		iconSize: (Point) (can be set through CSS)
+		iconAnchor: (Point) (centered by default if size is specified, can be set in CSS with negative margins)
+		popupAnchor: (Point) (if not specified, popup opens in the anchor point)
+		shadowUrl: (Point) (no shadow by default)
+		shadowSize: (Point)
+		*/
+		className: ''
+	},
+
+	initialize: function (options) {
+		L.Util.setOptions(this, options);
+	},
+
+	createIcon: function () {
+		return this._createIcon('icon');
+	},
+
+	createShadow: function () {
+		return this.options.shadowUrl ? this._createIcon('shadow') : null;
+	},
+
+	_createIcon: function (name) {
+		var img = this._createImg(this.options[name + 'Url']);
+		this._setIconStyles(img, name);
+		return img;
+	},
+
+	_setIconStyles: function (img, name) {
+		var options = this.options,
+			size = options[name + 'Size'],
+			anchor = options.iconAnchor;
+
+		if (!anchor && size) {
+			anchor = size.divideBy(2, true);
+		}
+
+		if (name === 'shadow' && anchor && options.shadowOffset) {
+			anchor._add(options.shadowOffset);
+		}
+
+		img.className = 'leaflet-marker-' + name + ' ' + options.className;
+
+		if (anchor) {
+			img.style.marginLeft = (-anchor.x) + 'px';
+			img.style.marginTop  = (-anchor.y) + 'px';
+		}
+
+		if (size) {
+			img.style.width  = size.x + 'px';
+			img.style.height = size.y + 'px';
+		}
+	},
+
+	_createImg: function (src) {
+		var el;
+		if (!L.Browser.ie6) {
+			el = document.createElement('img');
+			el.src = src;
+		} else {
+			el = document.createElement('div');
+			el.style.filter = 'progid:DXImageTransform.Microsoft.AlphaImageLoader(src="' + src + '")';
+		}
+		return el;
+	},
+
+	// new functions start here
+	switchIcon: function (el) {
+		return this._switchIcon('icon', el);
+	},
+
+	switchShadow: function (el) {
+		return this.options.shadowUrl ? this._switchIcon('shadow', el) : null;
+	},
+
+	_switchIcon: function (name, el) {
+		var img = this._switchImg(this.options[name + 'Url'], el);
+		this._setIconStyles(img, name);
+		return img;
+	},	
+	
+	_switchImg: function (src, el) {
+		if (!L.Browser.ie6) {
+			el.src = src;
+		} else {
+			el.style.filter = 'progid:DXImageTransform.Microsoft.AlphaImageLoader(src="' + src + '")';
+		}
+		return el;
+	}	
+});

WebContent/OSRM.Browser.js

@@ -0,0 +1,42 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM old browser support
+// [simple browser detection and routines to support some old browsers] 
+
+
+// browser detection (runs anonymous function to prevent local variables cluttering global namespace)
+(function() {
+	var useragent = navigator.userAgent;
+	
+	OSRM.Browser = {
+ 		FF3:	useragent.search(/Firefox\/3/),
+		IE6_9:	useragent.search(/MSIE (6|7|8|9)/)
+	};
+}());
+
+
+// compatibility tools for old browsers
+function getElementsByClassName(node, classname) {
+    var a = [];
+    var re = new RegExp('(^| )'+classname+'( |$)');
+    var els = node.getElementsByTagName("*");
+    for(var i=0,j=els.length; i<j; i++)
+        if(re.test(els[i].className))a.push(els[i]);
+    return a;
+}
+document.head = document.head || document.getElementsByTagName('head')[0];

WebContent/OSRM.EventHandler.js

@@ -0,0 +1,61 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM EventHandler
+// [adds simple event handling: other classes can derive from this class to acquire custom event handling]
+
+
+OSRM.EventHandler = function() {
+	this._listeners = {};
+};
+
+OSRM.extend( OSRM.EventHandler, {
+	
+	// add listener
+	addListener: function(type, listener) {
+		if( this._listeners[type] == undefined)
+			this._listeners[type] = [];
+		this._listeners[type].push(listener);
+	},
+	
+	//remove event listener
+	removeListener: function(type, listener) {
+		if( this._listeners[type] != undefined) {
+			for(var i=0; i<this._listeners[type].length; i++)
+				if( this._listeners[type][i] == listener) {
+					this._listeners[type].splice(i,1);
+					break;
+				}
+		}
+	},
+	
+	// fire event
+	fire: function(event) {
+		if( typeof event == "string")
+			event = {type:event};
+		if( !event.target )
+			event.target = this;
+		
+		if( !event.type )
+			throw new Error("event object missing type property!");
+		
+		if( this._listeners[type] != undefined)
+			for(var listener in this._listeners[event.type])
+				listener.call(this, event);
+	}
+	
+});

WebContent/OSRM.GUI.js

@@ -0,0 +1,103 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM GUI functionality
+// [responsible for all non-routing related GUI behaviour]
+
+
+OSRM.GUI = {
+		
+// defaults
+visible: null,
+width: null,
+
+// init GUI
+init: function() {
+	OSRM.GUI.visible = true;
+	OSRM.GUI.width = document.getElementById("main-wrapper").clientWidth;
+	
+	// translate
+	document.getElementById("open-josm").innerHTML = OSRM.loc("OPEN_JOSM");
+	document.getElementById("open-osmbugs").innerHTML = OSRM.loc("OPEN_OSMBUGS");	
+	document.getElementById("gui-reset").innerHTML = OSRM.loc("GUI_RESET");
+	document.getElementById("gui-reverse").innerHTML = OSRM.loc("GUI_REVERSE");
+	document.getElementById("gui-option-highlight-nonames-label").innerHTML = OSRM.loc("GUI_HIGHLIGHT_UNNAMED_ROADS");
+	document.getElementById("options-toggle").innerHTML = OSRM.loc("GUI_OPTIONS");
+	document.getElementById("gui-search-source").innerHTML = OSRM.loc("GUI_SEARCH");
+	document.getElementById("gui-search-target").innerHTML = OSRM.loc("GUI_SEARCH");
+	document.getElementById("gui-search-source-label").innerHTML = OSRM.loc("GUI_START")+":";
+	document.getElementById("gui-search-target-label").innerHTML = OSRM.loc("GUI_END")+":";
+	document.getElementById("input-source-name").title = OSRM.loc("GUI_START_TOOLTIP");
+	document.getElementById("input-target-name").title = OSRM.loc("GUI_END_TOOLTIP");
+	document.getElementById("legal-notice").innerHTML = OSRM.loc("GUI_LEGAL_NOTICE");
+	
+	document.getElementById('input-source-name').value = OSRM.DEFAULTS.ONLOAD_SOURCE;
+	document.getElementById('input-target-name').value = OSRM.DEFAULTS.ONLOAD_TARGET;	
+},
+		
+// show/hide main-gui
+toggleMain: function() {
+	// show main-gui
+	if( OSRM.GUI.visible == false ) {
+		getElementsByClassName(document,'leaflet-control-zoom')[0].style.visibility="hidden";
+		getElementsByClassName(document,'leaflet-control-zoom')[0].style.left=(OSRM.GUI.width+10)+"px";;
+		
+		document.getElementById('blob-wrapper').style.visibility="hidden";
+		document.getElementById('main-wrapper').style.left="5px";
+	// hide main-gui
+	} else {
+		getElementsByClassName(document,'leaflet-control-zoom')[0].style.visibility="hidden";
+		getElementsByClassName(document,'leaflet-control-zoom')[0].style.left="30px";
+			
+		document.getElementById('main-wrapper').style.left=-OSRM.GUI.width+"px";
+	}
+
+	// execute after animation
+	if( OSRM.Browser.FF3==-1 && OSRM.Browser.IE6_9==-1 ) {
+		document.getElementById('main-wrapper').addEventListener("transitionend", OSRM.GUI.onMainTransitionEnd, false);
+		document.getElementById('main-wrapper').addEventListener("webkitTransitionEnd", OSRM.GUI.onMainTransitionEnd, false);
+		document.getElementById('main-wrapper').addEventListener("oTransitionEnd", OSRM.GUI.onMainTransitionEnd, false);
+		document.getElementById('main-wrapper').addEventListener("MSTransitionEnd", OSRM.GUI.onMainTransitionEnd, false);
+	} else {
+		OSRM.GUI.onMainTransitionEnd();		
+	}
+},
+
+// do stuff after main-gui animation finished
+onMainTransitionEnd: function() {
+	// after hiding main-gui
+	if( OSRM.GUI.visible == true ) {
+		document.getElementById('blob-wrapper').style.visibility="visible";
+		getElementsByClassName(document,'leaflet-control-zoom')[0].style.visibility="visible";
+		OSRM.GUI.visible = false;		
+	// after showing main-gui
+	} else {
+		getElementsByClassName(document,'leaflet-control-zoom')[0].style.visibility="visible";
+ 		OSRM.GUI.visible = true;		
+	}
+},
+
+// show/hide small options bubble
+toggleOptions: function() {
+	if(document.getElementById('options-box').style.visibility=="visible") {
+		document.getElementById('options-box').style.visibility="hidden";
+	} else {
+		document.getElementById('options-box').style.visibility="visible";
+	}
+}
+
+};

WebContent/OSRM.Geocoder.js

@@ -0,0 +1,206 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM geocoding routines
+// [geocoder query, management and display of geocoder results]
+
+// some constants
+OSRM.CONSTANTS.SOURCE_LABEL = "source";
+OSRM.CONSTANTS.TARGET_LABEL = "target";
+OSRM.CONSTANTS.VIA_LABEL = "via";
+OSRM.CONSTANTS.DO_FALLBACK_TO_LAT_LNG = true;
+
+
+OSRM.Geocoder = {
+
+//[normal geocoding]
+
+// process input request and call geocoder if needed
+call: function(marker_id, query) {
+	if(query=="")
+		return;
+	
+	//geo coordinates given -> directly draw results
+	if(query.match(/^\s*[-+]?[0-9]*\.?[0-9]+\s*[,;]\s*[-+]?[0-9]*\.?[0-9]+\s*$/)){
+		var coord = query.split(/[,;]/);
+		OSRM.Geocoder._onclickResult(marker_id, coord[0], coord[1]);
+		OSRM.Geocoder.updateAddress( marker_id );
+		return;
+	}
+	
+	//build request for geocoder
+	var call = OSRM.DEFAULTS.HOST_GEOCODER_URL + "?format=json" + OSRM.DEFAULTS.GEOCODER_BOUNDS + "&q=" + query;
+	OSRM.JSONP.call( call, OSRM.Geocoder._showResults, OSRM.Geocoder._showResults_Timeout, OSRM.DEFAULTS.JSONP_TIMEOUT, "geocoder_"+marker_id, {marker_id:marker_id,query:query} );
+},
+
+
+// helper function for clicks on geocoder search results
+_onclickResult: function(marker_id, lat, lon) {
+	var index;
+	if( marker_id == OSRM.C.SOURCE_LABEL )
+		index = OSRM.G.markers.setSource( new L.LatLng(lat, lon) );
+	else if( marker_id == OSRM.C.TARGET_LABEL )
+		index = OSRM.G.markers.setTarget( new L.LatLng(lat, lon) );
+	else
+		return;
+	
+	OSRM.G.markers.route[index].show();
+	OSRM.G.markers.route[index].centerView();	
+	OSRM.Routing.getRoute();
+},
+
+
+// process geocoder response
+_showResults: function(response, parameters) {
+	if(!response){
+		OSRM.Geocoder._showResults_Empty(parameters);
+		return;
+	}
+	
+	if(response.length == 0) {
+		OSRM.Geocoder._showResults_Empty(parameters);
+		return;
+	}
+	
+	// show possible results for input
+	var html = "";
+	html += '<table class="results-table">';	
+	for(var i=0; i < response.length; i++){
+		var result = response[i];
+
+		//odd or even ?
+		var rowstyle='results-odd';
+		if(i%2==0) { rowstyle='results-even'; }
+ 
+		html += '<tr class="'+rowstyle+'">';
+		html += '<td class="result-counter"><span">'+(i+1)+'.</span></td>';
+		html += '<td class="result-items">';
+
+		if(result.display_name){
+			html += '<div class="result-item" onclick="OSRM.Geocoder._onclickResult(\''+parameters.marker_id+'\', '+result.lat+', '+result.lon+');">'+result.display_name+'</div>';
+		}
+		html += "</td></tr>";
+	}
+	html += '</table>';
+		
+	document.getElementById('information-box-headline').innerHTML = OSRM.loc("SEARCH_RESULTS")+":";
+	document.getElementById('information-box').innerHTML = html;
+
+	OSRM.Geocoder._onclickResult(parameters.marker_id, response[0].lat, response[0].lon);
+},
+_showResults_Empty: function(parameters) {
+	document.getElementById('information-box-headline').innerHTML = OSRM.loc("SEARCH_RESULTS")+":";
+	if(parameters.marker_id == OSRM.C.SOURCE_LABEL)
+		document.getElementById('information-box').innerHTML = "<br><p style='font-size:14px;font-weight:bold;text-align:center;'>"+OSRM.loc("NO_RESULTS_FOUND_SOURCE")+": "+parameters.query +".<p>";
+	else if(parameters.marker_id == OSRM.C.TARGET_LABEL)
+		document.getElementById('information-box').innerHTML = "<br><p style='font-size:14px;font-weight:bold;text-align:center;'>"+OSRM.loc("NO_RESULTS_FOUND_TARGET")+": "+parameters.query +".<p>";
+	else
+		document.getElementById('information-box').innerHTML = "<br><p style='font-size:14px;font-weight:bold;text-align:center;'>"+OSRM.loc("NO_RESULTS_FOUND")+": "+parameters.query +".<p>";
+},
+_showResults_Timeout: function() {
+	document.getElementById('information-box-headline').innerHTML = OSRM.loc("SEARCH_RESULTS")+":";
+	document.getElementById('information-box').innerHTML = "<br><p style='font-size:14px;font-weight:bold;text-align:center;'>"+OSRM.loc("TIMED_OUT")+".<p>";	
+},
+
+
+// [reverse geocoding]
+
+//update geo coordinates in input boxes
+updateLocation: function(marker_id) {
+	if (marker_id == OSRM.C.SOURCE_LABEL && OSRM.G.markers.hasSource()) {
+		document.getElementById("input-source-name").value = OSRM.G.markers.route[0].getLat().toFixed(6) + ", " + OSRM.G.markers.route[0].getLng().toFixed(6);
+	} else if (marker_id == OSRM.C.TARGET_LABEL && OSRM.G.markers.hasTarget()) {
+		document.getElementById("input-target-name").value = OSRM.G.markers.route[OSRM.G.markers.route.length-1].getLat().toFixed(6) + ", " + OSRM.G.markers.route[OSRM.G.markers.route.length-1].getLng().toFixed(6);		
+	}
+},
+
+
+// update address in input boxes
+updateAddress: function(marker_id, do_fallback_to_lat_lng) {
+	// build request for reverse geocoder
+	var lat = null;
+	var lng = null;
+	
+	if(marker_id == OSRM.C.SOURCE_LABEL && OSRM.G.markers.hasSource()) {
+		lat = OSRM.G.markers.route[0].getLat();
+		lng = OSRM.G.markers.route[0].getLng();		
+	} else if(marker_id == OSRM.C.TARGET_LABEL && OSRM.G.markers.hasTarget() ) {
+		lat = OSRM.G.markers.route[OSRM.G.markers.route.length-1].getLat();
+		lng = OSRM.G.markers.route[OSRM.G.markers.route.length-1].getLng();		
+	} else
+		return;
+	
+	var call = OSRM.DEFAULTS.HOST_REVERSE_GEOCODER_URL + "?format=json" + "&lat=" + lat + "&lon=" + lng;
+	OSRM.JSONP.call( call, OSRM.Geocoder._showReverseResults, OSRM.Geocoder._showReverseResults_Timeout, OSRM.DEFAULTS.JSONP_TIMEOUT, "reverse_geocoder_"+marker_id, {marker_id:marker_id, do_fallback: do_fallback_to_lat_lng} );
+},
+
+
+// processing JSONP response of reverse geocoder
+_showReverseResults: function(response, parameters) {
+ 	if(!response) {
+ 		OSRM.Geocoder._showReverseResults_Timeout(response, parameters);
+		return;
+	}
+ 	
+	if(response.address == undefined) {
+		OSRM.Geocoder._showReverseResults_Timeout(response, parameters);
+		return;
+	}
+
+	// build reverse geocoding address
+	var used_address_data = 0;
+	var address = "";
+	if( response.address.road) {
+		address += response.address.road;
+		used_address_data++;
+	}
+	if( response.address.city ) {
+		if( used_address_data > 0 )
+			address += ", ";
+		address += response.address.city;
+		used_address_data++;
+	} else if( response.address.village ) {
+		if( used_address_data > 0 )
+			address += ", ";
+		address += response.address.village;
+		used_address_data++;
+	}
+	if( used_address_data < 2 && response.address.country ) {
+		if( used_address_data > 0 )
+			address += ", ";
+		address += response.address.country;
+		used_address_data++;
+	}
+	if( used_address_data == 0 ) {
+		OSRM.Geocoder._showReverseResults_Timeout(response, parameters);
+		return;
+	}
+		
+	// add result to DOM
+	if(parameters.marker_id == OSRM.C.SOURCE_LABEL && OSRM.G.markers.hasSource() )
+		document.getElementById("input-source-name").value = address;
+	else if(parameters.marker_id == OSRM.C.TARGET_LABEL && OSRM.G.markers.hasTarget() )
+		document.getElementById("input-target-name").value = address;
+},
+_showReverseResults_Timeout: function(response, parameters) {
+	if(!parameters.do_fallback)
+		return;
+		
+	updateLocation(parameters.marker_id);
+}
+
+};

WebContent/OSRM.JSONP.js

@@ -0,0 +1,103 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM JSONP call wrapper 
+// [wrapper for JSONP calls with DOM cleaning, fencing, timout handling]
+
+
+OSRM.JSONP = {
+		
+	// storage to keep track of unfinished JSONP calls
+	fences: {},
+	callbacks: {},
+	timeouts: {},
+	timers: {},
+	
+	
+	// default callback routines
+	late: function() { /*OSRM.debug.log("[jsonp] reply too late");*/ },	
+	empty: function() { /*OSRM.debug.log("[jsonp] empty callback");*/ },
+	
+	
+	// init JSONP call
+	call: function(source, callback_function, timeout_function, timeout, id, parameters) {
+		// only one active JSONP call per id
+		if (OSRM.JSONP.fences[id] == true)
+			return false;
+		OSRM.JSONP.fences[id] = true;
+		
+		// wrap timeout function
+		OSRM.JSONP.timeouts[id] = function(response) {
+			try {
+				timeout_function(response, parameters);
+			} finally {
+				OSRM.JSONP.callbacks[id] = OSRM.JSONP.late;				// clean functions
+				OSRM.JSONP.timeouts[id] = OSRM.JSONP.empty;
+				OSRM.JSONP.fences[id] = undefined;						// clean fence
+			}
+			
+//			OSRM.debug.log("[jsonp] timout handling: "+id);
+		};
+		
+		// wrap callback function
+		OSRM.JSONP.callbacks[id] = function(response) {
+			clearTimeout(OSRM.JSONP.timers[id]);						// clear timeout timer
+			OSRM.JSONP.timers[id] = undefined;
+			
+			try {
+				callback_function(response, parameters);				// actual wrapped callback 
+			} finally {
+				OSRM.JSONP.callbacks[id] = OSRM.JSONP.empty;			// clean functions
+				OSRM.JSONP.timeouts[id] = OSRM.JSONP.late;
+				OSRM.JSONP.fences[id] = undefined;						// clean fence
+			}
+			
+//			OSRM.JSONP.sum[id] += new Number( new Date() - OSRM.JSONP.durations[id] );
+//			OSRM.debug.log("[jsonp] response handling: "+id+" "+ (OSRM.JSONP.sum[id]/OSRM.JSONP.counter[id]).toFixed(2) );
+		};
+		
+		// clean DOM (unfortunately, script elements cannot be reused by all browsers)
+		var jsonp = document.getElementById('jsonp_'+id);
+		if(jsonp)
+			jsonp.parentNode.removeChild(jsonp);
+		
+		// add script to DOM
+		var script = document.createElement('script');
+		script.type = 'text/javascript';
+		script.id = 'jsonp_'+id;
+		script.src = source + "&json_callback=OSRM.JSONP.callbacks."+id + "&jsonp=OSRM.JSONP.callbacks."+id;
+		document.head.appendChild(script);
+		
+		// start timeout timer
+		OSRM.JSONP.timers[id] = setTimeout(OSRM.JSONP.timeouts[id], timeout);
+		
+//		if(!OSRM.JSONP.durations) { OSRM.JSONP.durations = {}; OSRM.JSONP.counter = {}; OSRM.JSONP.sum = {}; }
+//		if(OSRM.JSONP.counter[id]) OSRM.JSONP.counter[id]++; else {OSRM.JSONP.counter[id] = 1;OSRM.JSONP.sum[id] = 0;}
+//		OSRM.JSONP.durations[id] = new Date();		
+//		OSRM.debug.log("[jsonp] init: "+id);
+		
+		return true;
+	},
+	
+	// reset all data
+	reset: function() {
+		OSRM.JSONP.fences = {};
+		OSRM.JSONP.callbacks = {};
+		OSRM.JSONP.timeouts = {};
+		OSRM.JSONP.timers = {};
+	}
+};

WebContent/OSRM.Localization.js

@@ -0,0 +1,122 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM localization
+// [basic localization options]
+
+
+OSRM.Localization = {
+		
+// if existing, return localized string -> English string -> input string
+translate: function(text) {
+	if( OSRM.Localization[OSRM.DEFAULTS.LANGUAGE][text] )
+		return OSRM.Localization[OSRM.DEFAULTS.LANGUAGE][text];
+	else if( OSRM.Localization["en"][text] )
+		return OSRM.Localization["en"][text];
+	else
+		return text;
+}
+};
+
+// shorter call to translate function
+OSRM.loc = OSRM.Localization.translate;
+
+
+// German language support
+OSRM.Localization["de"] = {
+//gui
+"OPEN_JOSM": "JOSM",
+"OPEN_OSMBUGS": "OSM Bugs",
+"GUI_START": "Start",
+"GUI_END": "Ziel",
+"GUI_RESET": "Reset",
+"GUI_SEARCH": "Zeigen",
+"GUI_REVERSE": "Umdrehen",
+"GUI_OPTIONS": "Kartenwerkzeuge",
+"GUI_HIGHLIGHT_UNNAMED_ROADS": "Unbenannte Straßen hervorheben",
+"GUI_START_TOOLTIP": "Startposition eingeben",
+"GUI_END_TOOLTIP": "Zielposition eingeben",
+"GUI_LEGAL_NOTICE": "GUI2 v"+OSRM.VERSION+" "+OSRM.DATE+" - OSRM hosting by <a href='http://algo2.iti.kit.edu/'>KIT</a> - Geocoder by <a href='http://www.osm.org/'>OSM</a>",
+// geocoder
+"SEARCH_RESULTS": "Suchergebnisse",
+"TIMED_OUT": "Zeitüberschreitung",
+"NO_RESULTS_FOUND": "Keine Ergebnisse gefunden",
+"NO_RESULTS_FOUND_SOURCE": "Keine Ergebnisse gefunden für Start",
+"NO_RESULTS_FOUND_TARGET": "Keine Ergebnisse gefunden für Ziel",
+// routing
+"ROUTE_DESCRIPTION": "Routenbeschreibung",
+"GET_LINK_TO_ROUTE": "Generiere Link",
+"GENERATE_LINK_TO_ROUTE": "Warte auf Antwort",
+"LINK_TO_ROUTE_TIMEOUT": "nicht möglich",
+"GPX_FILE": "GPX Datei",
+"DISTANCE": "Distanz",
+"DURATION": "Dauer",
+"YOUR_ROUTE_IS_BEING_COMPUTED": "Ihre Route wird berechnet",
+"NO_ROUTE_FOUND": "Keine Route hierher möglich",
+// directions
+"N": "Norden",
+"O": "Ost",
+"S": "Süden",
+"W": "Westen",
+"NO": "Nordost",
+"SO": "Südost",
+"SW": "Südwest",
+"NW": "Nordwest"
+};
+
+
+// English language support
+OSRM.Localization["en"] = {
+//gui
+"OPEN_JOSM": "JOSM",
+"OPEN_OSMBUGS": "OSM Bugs",
+"GUI_START": "Start",
+"GUI_END": "End",
+"GUI_RESET": "&nbsp;&nbsp;Reset&nbsp;&nbsp;",
+"GUI_SEARCH": "&nbsp;&nbsp;Show&nbsp;&nbsp;",
+"GUI_REVERSE": "Reverse",
+"GUI_OPTIONS": "Mapping Tools",
+"GUI_HIGHLIGHT_UNNAMED_ROADS": "Highlight unnamed streets",
+"GUI_START_TOOLTIP": "Enter start",
+"GUI_END_TOOLTIP": "Enter destination",
+"GUI_LEGAL_NOTICE": "GUI2 v"+OSRM.VERSION+" "+OSRM.DATE+" - OSRM hosting by <a href='http://algo2.iti.kit.edu/'>KIT</a> - Geocoder by <a href='http://www.osm.org/'>OSM</a>",
+// geocoder
+"SEARCH_RESULTS": "Search Results",
+"TIMED_OUT": "Timed Out",
+"NO_RESULTS_FOUND": "No results found",
+"NO_RESULTS_FOUND_SOURCE": "No results found for start",
+"NO_RESULTS_FOUND_TARGET": "No results found for end",
+//routing
+"ROUTE_DESCRIPTION": "Route Description",
+"GET_LINK_TO_ROUTE": "Generate Link",
+"GENERATE_LINK_TO_ROUTE": "waiting for link",
+"LINK_TO_ROUTE_TIMEOUT": "not available",
+"GPX_FILE": "GPX File",
+"DISTANCE": "Distance",
+"DURATION": "Duration",
+"YOUR_ROUTE_IS_BEING_COMPUTED": "Your route is being computed",
+"NO_ROUTE_FOUND": "No route possible",
+// directions
+"N": "north",
+"E": "east",
+"S": "south",
+"W": "west",
+"NE": "northeast",
+"SE": "southeast",
+"SW": "southwest",
+"NW": "northwest"
+};

WebContent/OSRM.Map.js

@@ -0,0 +1,151 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM map handling
+// [initialization, event handling, centering relative to UI]
+
+// will hold the map object
+OSRM.GLOBALS.map = null;
+
+
+// map view/model
+// [extending Leaflet L.Map with setView/fitBounds methods that respect UI visibility] 
+OSRM.MapView = L.Map.extend({
+	setViewUI: function(position, zoom) {
+		if( OSRM.GUI.visible == true ) {
+			var point = OSRM.G.map.project( position, zoom);
+			point.x-=OSRM.GUI.width/2;
+			position = OSRM.G.map.unproject(point,zoom);		
+		}
+		this.setView( position, zoom);	
+	},
+	fitBoundsUI: function(bounds) {
+		var southwest = bounds.getSouthWest();
+		var northeast = bounds.getNorthEast();
+		var zoom = OSRM.G.map.getBoundsZoom(bounds);
+		var sw_point = OSRM.G.map.project( southwest, zoom);
+		if( OSRM.GUI.visible == true )
+			sw_point.x-=OSRM.GUI.width/2;
+		else
+			sw_point.x-=10;
+		sw_point.y+=10;
+		var ne_point = OSRM.G.map.project( northeast, zoom);
+		ne_point.y-=10;
+		sw_point.x+=10;
+		bounds.extend( OSRM.G.map.unproject(sw_point,zoom) );
+		bounds.extend( OSRM.G.map.unproject(ne_point,zoom) );
+		this.fitBounds( bounds );	
+	},
+	getCenterUI: function(unbounded) {
+		var viewHalf = this.getSize();
+		if( OSRM.GUI.visible == true )
+			viewHalf.x += OSRM.GUI.width;
+		var centerPoint = this._getTopLeftPoint().add(viewHalf.divideBy(2));
+		
+		return this.unproject(centerPoint, this._zoom, unbounded);
+	}
+});
+
+
+// map controller
+// [map initialization, event handling]
+OSRM.Map = {
+
+// map initialization
+init: function() {
+	// check if GUI is initialized!
+	if(OSRM.GUI.visible == null)
+		OSRM.GUI.init();
+	
+	// setup tile servers
+	var osmorgURL = 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
+		osmorgAttribution = 'Map data © 2011 OpenStreetMap contributors, Imagery © 2011 Mapnik',
+		osmorgOptions = {maxZoom: 18, attribution: osmorgAttribution};
+
+	var osmdeURL = 'http://{s}.tile.openstreetmap.de/tiles/osmde/{z}/{x}/{y}.png',
+		osmdeAttribution = 'Map data © 2011 OpenStreetMap contributors, Imagery © 2011 Mapnik',
+		osmdeOptions = {maxZoom: 18, attribution: osmdeAttribution};
+	
+	var mapquestURL = 'http://otile{s}.mqcdn.com/tiles/1.0.0/osm/{z}/{x}/{y}.png',
+		mapquestAttribution = 'Map data © 2011 OpenStreetMap contributors, Imagery © 2011 MapQuest',
+		mapquestOptions = {maxZoom: 18, attribution: mapquestAttribution, subdomains: '1234'};	
+	
+	var cloudmadeURL = 'http://{s}.tile.cloudmade.com/BC9A493B41014CAABB98F0471D759707/997/256/{z}/{x}/{y}.png',
+    	cloudmadeAttribution = 'Map data © 2011 OpenStreetMap contributors, Imagery © 2011 CloudMade',
+	    cloudmadeOptions = {maxZoom: 18, attribution: cloudmadeAttribution};
+
+	var osmorg = new L.TileLayer(osmorgURL, osmorgOptions),
+    	osmde = new L.TileLayer(osmdeURL, osmdeOptions),
+    	mapquest = new L.TileLayer(mapquestURL, mapquestOptions),
+	    cloudmade = new L.TileLayer(cloudmadeURL, cloudmadeOptions);
+
+	// setup map
+	OSRM.G.map = new OSRM.MapView('map', {
+    	center: new L.LatLng(51.505, -0.09),
+	    zoom: 13,
+	    zoomAnimation: false,					// false: removes animations and hiding of routes during zoom
+	    fadeAnimation: false,
+	    layers: [osmorg]
+	});
+
+	// add tileservers
+	var baseMaps = {
+		"osm.org": osmorg,
+		"osm.de": osmde,
+		"MapQuest": mapquest,
+		"CloudMade": cloudmade
+	};
+
+	var overlayMaps = {};
+	var layersControl = new L.Control.Layers(baseMaps, overlayMaps);
+	OSRM.G.map.addControl(layersControl);
+
+    // move zoom markers
+	getElementsByClassName(document,'leaflet-control-zoom')[0].style.left=(OSRM.GUI.width+10)+"px";
+	getElementsByClassName(document,'leaflet-control-zoom')[0].style.top="5px";
+
+	// initial map position and zoom
+	var position = new L.LatLng( OSRM.DEFAULTS.ONLOAD_LATITUDE, OSRM.DEFAULTS.ONLOAD_LONGITUDE);
+	OSRM.G.map.setViewUI( position, OSRM.DEFAULTS.ZOOM_LEVEL);
+
+	// map events
+	OSRM.G.map.on('zoomend', OSRM.Map.zoomed );
+	OSRM.G.map.on('click', OSRM.Map.click );
+	OSRM.G.map.on('contextmenu', OSRM.Map.contextmenu );
+	OSRM.G.map.on('mousemove', OSRM.Map.mousemove );
+},
+
+// map event handlers
+zoomed: function(e) { OSRM.Routing.getRoute(); },
+contextmenu: function(e) {;},
+mousemove: function(e) { OSRM.Via.drawDragMarker(e); },
+click: function(e) {
+	if( !OSRM.G.markers.hasSource() ) {
+		var index = OSRM.G.markers.setSource( e.latlng );
+		OSRM.Geocoder.updateAddress( OSRM.C.SOURCE_LABEL, OSRM.C.DO_FALLBACK_TO_LAT_LNG );
+		OSRM.G.markers.route[index].show();
+		OSRM.G.markers.route[index].centerView( OSRM.G.map.getZoom() );
+		OSRM.Routing.getRoute();
+	} else if( !OSRM.G.markers.hasTarget() ) {
+		var index = OSRM.G.markers.setTarget( e.latlng );
+		OSRM.Geocoder.updateAddress( OSRM.C.TARGET_LABEL, OSRM.C.DO_FALLBACK_TO_LAT_LNG );
+		OSRM.G.markers.route[index].show();
+		OSRM.G.markers.route[index].centerView( OSRM.G.map.getZoom() );
+		OSRM.Routing.getRoute();
+	}	
+}
+};

WebContent/OSRM.Markers.js

@@ -0,0 +1,245 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM markers 
+// [base marker class, derived highlight marker and route marker classes, marker management]  
+
+
+// base marker class (wraps Leaflet markers)
+OSRM.Marker = function( label, style, position ) {
+	this.label = label ? label : "marker";
+	this.position = position ? position : new L.LatLng(0,0);
+
+	this.marker = new L.MouseMarker( this.position, style );
+	this.marker.parent = this;
+	
+	this.shown = false;
+	this.hint = null;
+};
+OSRM.extend( OSRM.Marker,{
+show: function() {
+	OSRM.G.map.addLayer(this.marker);
+	this.shown = true;
+},
+hide: function() {
+	OSRM.G.map.removeLayer(this.marker);
+	this.shown = false;
+},
+setPosition: function( position ) {
+	this.position = position;
+	this.marker.setLatLng( position );
+	this.hint = null;	
+},
+getPosition: function() {
+	return this.position;
+},
+getLat: function() {
+	return this.position.lat;
+},
+getLng: function() {
+	return this.position.lng;
+},
+isShown: function() {
+	return this.shown;
+},
+centerView: function(zoom) {
+	if( zoom == undefined )
+		zoom = OSRM.DEFAULTS.ZOOM_LEVEL;
+	OSRM.G.map.setViewUI( this.position, zoom );
+},
+toString: function() {
+	return "OSRM.Marker: \""+this.label+"\", "+this.position+")";
+}
+});
+
+
+// route marker class (draggable, invokes route drawing routines) 
+OSRM.RouteMarker = function ( label, style, position ) {
+	style.baseicon = style.icon;
+	OSRM.RouteMarker.prototype.base.constructor.apply( this, arguments );
+	this.label = label ? label : "route_marker";
+
+ 	this.marker.on( 'click', this.onClick );
+ 	this.marker.on( 'drag', this.onDrag );
+ 	this.marker.on( 'dragstart', this.onDragStart );
+ 	this.marker.on( 'dragend', this.onDragEnd );
+};
+OSRM.inheritFrom( OSRM.RouteMarker, OSRM.Marker );
+OSRM.extend( OSRM.RouteMarker, {
+onClick: function(e) {
+	for( var i=0; i<OSRM.G.markers.route.length; i++) {
+		if( OSRM.G.markers.route[i].marker === this ) {
+			OSRM.G.markers.removeMarker( i );
+			break;
+		}
+	}
+	
+	OSRM.Routing.getRoute();
+	OSRM.G.markers.highlight.hide();
+},
+onDrag: function(e) {
+	this.parent.setPosition( e.target.getLatLng() );
+	if(OSRM.G.markers.route.length>1)
+		OSRM.Routing.getDragRoute();
+	OSRM.Geocoder.updateLocation( this.parent.label );
+},
+onDragStart: function(e) {
+	OSRM.G.dragging = true;
+	this.switchIcon(this.options.dragicon);
+	
+	// store id of dragged marker
+	for( var i=0; i<OSRM.G.markers.route.length; i++)
+		if( OSRM.G.markers.route[i].marker === this ) {
+			OSRM.G.dragid = i;
+			break;
+		}
+	
+	if( this.parent != OSRM.G.markers.highlight)
+		OSRM.G.markers.highlight.hide();	
+	if (OSRM.G.route.isShown())
+		OSRM.G.route.showOldRoute();
+},
+onDragEnd: function(e) {
+	OSRM.G.dragging = false;
+	this.switchIcon(this.options.baseicon);
+	
+	this.parent.setPosition( e.target.getLatLng() );	
+	OSRM.Routing.getRoute();
+	if (OSRM.G.route.isShown()) {
+		OSRM.G.route.hideOldRoute();
+		OSRM.G.route.hideUnnamedRoute();
+	}
+	
+	if(OSRM.G.route.isShown()==false)
+		OSRM.Geocoder.updateAddress(this.parent.label);
+},
+toString: function() {
+	return "OSRM.RouteMarker: \""+this.label+"\", "+this.position+")";
+}
+});
+
+
+//drag marker class (draggable, invokes route drawing routines) 
+OSRM.DragMarker = function ( label, style, position ) {
+	OSRM.DragMarker.prototype.base.constructor.apply( this, arguments );
+	this.label = label ? label : "drag_marker";
+};
+OSRM.inheritFrom( OSRM.DragMarker, OSRM.RouteMarker );
+OSRM.extend( OSRM.DragMarker, {
+onClick: function(e) {
+	this.parent.hide();
+},
+onDragStart: function(e) {
+	var new_via_index = OSRM.Via.findViaIndex( e.target.getLatLng() );
+	OSRM.G.markers.route.splice(new_via_index+1,0, this.parent );
+
+	OSRM.RouteMarker.prototype.onDragStart.call(this,e);
+},
+onDragEnd: function(e) {
+	OSRM.G.markers.route[OSRM.G.dragid] = new OSRM.RouteMarker(OSRM.C.VIA_LABEL, {draggable:true,icon:OSRM.G.icons['marker-via'],dragicon:OSRM.G.icons['marker-via-drag']}, e.target.getLatLng() );
+	OSRM.G.markers.route[OSRM.G.dragid].show();
+	
+	OSRM.RouteMarker.prototype.onDragEnd.call(this,e);
+	this.parent.hide();
+},
+toString: function() {
+	return "OSRM.DragMarker: \""+this.label+"\", "+this.position+")";
+}
+});
+
+
+// marker management class (all route markers should only be set and deleted with these routines!)
+// [this holds the vital information of the route]
+OSRM.Markers = function() {
+	this.route = new Array();
+	this.highlight = new OSRM.DragMarker("highlight", {draggable:true,icon:OSRM.G.icons['marker-highlight'],dragicon:OSRM.G.icons['marker-highlight-drag']});;
+	this.dragger = new OSRM.DragMarker("drag", {draggable:true,icon:OSRM.G.icons['marker-drag'],dragicon:OSRM.G.icons['marker-drag']});;
+};
+OSRM.extend( OSRM.Markers,{
+removeAll: function() {
+	for(var i=0; i<this.route.length;i++)
+		this.route[i].hide();
+	this.route.splice(0, this.route.length);
+	document.getElementById('delete-source-marker').style.visibility = "hidden";
+	document.getElementById('delete-target-marker').style.visibility = "hidden";
+},
+removeVias: function() {
+	// assert correct route array s - v - t
+	for(var i=1; i<this.route.length-1;i++)
+		this.route[i].hide();
+	this.route.splice(1, this.route.length-2);
+},
+setSource: function(position) {
+	// source node is always first node
+	if( this.route[0] && this.route[0].label == OSRM.C.SOURCE_LABEL )
+		this.route[0].setPosition(position);
+	else
+		this.route.splice(0,0, new OSRM.RouteMarker(OSRM.C.SOURCE_LABEL, {draggable:true,icon:OSRM.G.icons['marker-source'],dragicon:OSRM.G.icons['marker-source-drag']}, position));
+	document.getElementById('delete-source-marker').style.visibility = "visible";
+	return 0;	
+},
+setTarget: function(position) {
+	// target node is always last node
+	if( this.route[this.route.length-1] && this.route[ this.route.length-1 ].label == OSRM.C.TARGET_LABEL )
+		this.route[this.route.length-1].setPosition(position);
+	else
+		this.route.splice( this.route.length,0, new OSRM.RouteMarker(OSRM.C.TARGET_LABEL, {draggable:true,icon:OSRM.G.icons['marker-target'],dragicon:OSRM.G.icons['marker-target-drag']}, position));
+	document.getElementById('delete-target-marker').style.visibility = "visible";
+	return this.route.length-1;
+},
+setVia: function(id, position) {
+	// via nodes only between source and target nodes
+	if( this.route.length<2 || id > this.route.length-2 )
+		return -1;
+	
+	this.route.splice(id+1,0, new OSRM.RouteMarker(OSRM.C.VIA_LABEL, {draggable:true,icon:OSRM.G.icons['marker-via'],dragicon:OSRM.G.icons['marker-via-drag']}, position));
+	return id+1;
+},
+removeMarker: function(id) {
+	if( id >= this.route.length )
+		return;
+	
+	// also remove vias if source or target are removed
+	if( id==0 && this.route[0].label == OSRM.C.SOURCE_LABEL ) {
+		this.removeVias();
+		document.getElementById('input-source-name').value = "";
+		document.getElementById('information-box').innerHTML = "";
+		document.getElementById('information-box-headline').innerHTML = "";
+		document.getElementById('delete-source-marker').style.visibility = "hidden";
+	} else if( id == this.route.length-1 && this.route[ this.route.length-1 ].label == OSRM.C.TARGET_LABEL ) {
+		this.removeVias();
+		id = this.route.length-1;
+		document.getElementById('input-target-name').value = "";
+		document.getElementById('information-box').innerHTML = "";
+		document.getElementById('information-box-headline').innerHTML = "";
+		document.getElementById('delete-target-marker').style.visibility = "hidden";
+	}
+	
+	this.route[id].hide();
+	this.route.splice(id, 1);
+},
+hasSource: function() {
+	if( OSRM.G.markers.route[0] && OSRM.G.markers.route[0].label == OSRM.C.SOURCE_LABEL )
+		return true;
+	return false;
+},
+hasTarget: function() {
+	if( OSRM.G.markers.route[OSRM.G.markers.route.length-1] && OSRM.G.markers.route[OSRM.G.markers.route.length-1].label == OSRM.C.TARGET_LABEL )
+		return true;
+	return false;
+}
+});

WebContent/OSRM.Route.js

@@ -0,0 +1,193 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM routes
+// [drawing of all types of route geometry] 
+
+
+// simple route class (wraps Leaflet Polyline)
+OSRM.SimpleRoute = function (label, style) {
+	this.label = (label ? label : "route");
+	this.route = new L.DashedPolyline();
+	this.route.setLatLngs( [] );
+	if(style) this.route.setStyle( style );
+
+	this.shown = false;
+};
+OSRM.extend( OSRM.SimpleRoute,{
+show: function() {
+	OSRM.G.map.addLayer(this.route);
+	this.shown = true;
+},
+hide: function() {
+	OSRM.G.map.removeLayer(this.route);
+	this.shown = false;
+},
+isShown: function() {
+	return this.shown;
+},
+getPoints: function() {
+	return this.route._originalPoints;
+},
+getPositions: function() {
+	return this.route.getLatLngs();
+},
+setPositions: function(positions) {
+	this.route.setLatLngs( positions );
+},
+setStyle: function(style) {
+	this.route.setStyle(style);
+},
+centerView: function() {
+	var bounds = new L.LatLngBounds( this.getPositions() );
+	OSRM.g.map.fitBoundsUI( bounds );
+},
+toString: function() {
+	return "OSRM.Route("+ this.label + ", " + this.route.getLatLngs().length + " points)";
+}
+});
+
+
+// multiroute class (wraps Leaflet LayerGroup to hold several disjoint routes)
+OSRM.MultiRoute = function (label) {
+	this.label = (label ? label : "multiroute");
+	this.route = new L.LayerGroup();
+
+	this.shown = false;
+};
+OSRM.extend( OSRM.MultiRoute,{
+show: function() {
+	OSRM.G.map.addLayer(this.route);
+	this.shown = true;
+},
+hide: function() {
+	OSRM.G.map.removeLayer(this.route);
+	this.shown = false;
+},
+isShown: function() {
+	return this.shown;
+},
+addRoute: function(positions) {
+	var line = new L.DashedPolyline( positions );
+	line.on('click', function(e) { OSRM.G.route.fire('click',e); });
+	this.route.addLayer( line );
+},
+clearRoutes: function() {
+	this.route.clearLayers();
+},
+setStyle: function(style) {
+	this.route.invoke('setStyle', style);
+},
+toString: function() {
+	return "OSRM.MultiRoute("+ this.label + ")";
+}
+});
+
+
+// route management (handles drawing of route geometry - current route, old route, unnamed route, highlight unnamed streets) 
+// [this holds the route geometry]
+OSRM.Route = function() {
+	this._current_route	= new OSRM.SimpleRoute("current" , {dashed:false} );
+	this._old_route		= new OSRM.SimpleRoute("old", {dashed:false,color:"#123"} );
+	this._unnamed_route	= new OSRM.MultiRoute("unnamed");
+	
+	this._current_route_style	= {dashed:false,color:'#0033FF', weight:5};
+	this._current_noroute_style	= {dashed:true, color:'#222222', weight:2};
+	this._old_route_style	= {dashed:false,color:'#112233', weight:5};
+	this._old_noroute_style	= {dashed:true, color:'#000000', weight:2};
+	this._unnamed_route_style = {dashed:false, color:'#FF00FF', weight:10};
+	this._old_unnamed_route_style = {dashed:false, color:'#990099', weight:10};
+	
+	this._noroute = OSRM.Route.ROUTE;
+};
+OSRM.Route.NOROUTE = true;
+OSRM.Route.ROUTE = false;
+OSRM.extend( OSRM.Route,{
+	
+	showRoute: function(positions, noroute) {
+		this._noroute = noroute;
+		this._current_route.setPositions( positions );
+		if ( this._noroute == OSRM.Route.NOROUTE )
+			this._current_route.setStyle( this._current_noroute_style );
+		else
+			this._current_route.setStyle( this._current_route_style );
+		this._current_route.show();
+		//this._raiseUnnamedRoute();
+	},
+	hideRoute: function() {
+		this._current_route.hide();
+		this._unnamed_route.hide();
+	},
+	hideAll: function() {
+		this._current_route.hide();
+		this._unnamed_route.hide();
+		this._old_route.hide();
+		this._noroute = OSRM.Route.ROUTE;
+	},	
+	
+	showUnnamedRoute: function(positions) {
+		this._unnamed_route.clearRoutes();
+		for(var i=0; i<positions.length; i++) {
+			this._unnamed_route.addRoute(positions[i]);	
+		}
+		this._unnamed_route.setStyle( this._unnamed_route_style );
+		this._unnamed_route.show();
+	},
+	hideUnnamedRoute: function() {
+		this._unnamed_route.hide();
+	},
+	// TODO: hack to put unnamed_route above old_route -> easier way in will be available Leaflet 0.4	
+	_raiseUnnamedRoute: function() {
+		if(this._unnamed_route.isShown()) {
+			this._unnamed_route.hide();
+			this._unnamed_route.show();
+		}		
+	},	
+	showOldRoute: function() {
+		this._old_route.setPositions( this._current_route.getPositions() );
+		if ( this._noroute == OSRM.Route.NOROUTE)
+			this._old_route.setStyle( this._old_noroute_style );
+		else
+			this._old_route.setStyle( this._old_route_style );
+		this._old_route.show();
+		this._raiseUnnamedRoute();
+		// change color of unnamed route highlighting - no separate object as dragged route does not have unnamed route highlighting
+		this._unnamed_route.setStyle( this._old_unnamed_route_style );
+	},
+	hideOldRoute: function() {
+		this._old_route.hide();
+	},
+	
+	isShown: function() {
+		return this._current_route.isShown();
+	},
+	isRoute: function() {
+		return !(this._noroute);
+	},	
+	getPositions: function() {
+		return this._current_route.getPositions();
+	},
+	getPoints: function() {
+		return this._current_route.getPoints();
+	},	
+	fire: function(type,event) {
+		this._current_route.route.fire(type,event);
+	},
+	centerView: function() {
+		this._current_route.centerView();
+	}
+});

WebContent/OSRM.Utils.js

@@ -0,0 +1,67 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM utility functions
+// [mixed functions]
+
+
+OSRM.Utils = {
+		
+// [human readabilty functions]
+
+// human readable time
+secondsToTime: function(seconds){
+   seconds = parseInt(seconds);
+   minutes = parseInt(seconds/60);
+   seconds = seconds%60;
+   hours = parseInt(minutes/60);
+   minutes = minutes%60;
+   if(hours==0){
+   	return minutes + ' ' + 'min';
+   }
+   else{
+   	return hours + ' ' + 'h' + ' ' + minutes + ' ' + 'min';
+   }
+},
+//human readable distance
+metersToDistance: function(distance){
+	distance = parseInt(distance);
+	
+	if(distance >= 100000){ return (parseInt(distance/1000))+' ' + 'km'; }
+	else if(distance >= 10000){ return (parseInt(distance/1000).toFixed(1))+' ' + 'km'; }
+	else if(distance >= 1000){ return (parseFloat(distance/1000).toFixed(2))+' ' + 'km'; }
+	else{ return distance+' ' + 'm'; }
+},
+
+
+// [verification routines]
+
+// verify angles
+isLatitude: function(value) {
+	if( value >=-90 && value <=90)
+		return true;
+	else
+		return false;
+},
+isLongitude: function(value) {
+	if( value >=-180 && value <=180)
+		return true;
+	else
+		return false;
+}
+
+};

WebContent/OSRM.Via.js

@@ -0,0 +1,121 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM via marker routines
+// [find correct position for a via marker]
+
+// store location of via points returned by server
+OSRM.GLOBALS.via_points = null;
+
+
+OSRM.Via = {
+		
+// find route segment of current route geometry that is closest to the new via node (marked by index of its endpoint)
+_findNearestRouteSegment: function( new_via ) {
+	var min_dist = Number.MAX_VALUE;
+	var min_index = undefined;
+
+	var p = OSRM.G.map.latLngToLayerPoint( new_via );
+	var positions = OSRM.G.route.getPoints();
+	for(var i=1; i<positions.length; i++) {
+		var _sqDist = L.LineUtil._sqClosestPointOnSegment(p, positions[i-1], positions[i], true);
+		if( _sqDist < min_dist) {
+			min_dist = _sqDist;
+			min_index = i;
+		}
+	}
+
+	return min_index;
+},
+
+
+// find the correct index among all via nodes to insert the new via node, and insert it  
+findViaIndex: function( new_via_position ) {
+	// find route segment that is closest to click position (marked by last index)
+	var nearest_index = OSRM.Via._findNearestRouteSegment( new_via_position );
+
+	// find correct index to insert new via node
+	var new_via_index = OSRM.G.via_points.length;
+	var via_index = Array();
+	for(var i=0; i<OSRM.G.via_points.length; i++) {
+		via_index[i] = OSRM.Via._findNearestRouteSegment( new L.LatLng(OSRM.G.via_points[i][0], OSRM.G.via_points[i][1]) );
+		if(via_index[i] > nearest_index) {
+			new_via_index = i;
+			break;
+		}
+	}
+
+	// add via node
+	return new_via_index;
+},
+
+
+//function that draws a drag marker
+dragTimer: new Date(),
+
+drawDragMarker: function(event) {
+	if( OSRM.G.route.isShown() == false)
+		return;
+	if( OSRM.G.dragging == true )
+		return;
+	
+	// throttle computation
+	if( (new Date() - OSRM.Via.dragTimer) < 25 )
+		return;
+	OSRM.Via.dragTimer = new Date();
+	
+	// get distance to route
+	var minpoint = OSRM.G.route._current_route.route.closestLayerPoint( event.layerPoint );
+	var min_dist = minpoint._sqDist;
+	
+	// get distance to markers
+	var mouse = event.latlng;
+	for(var i=0, size=OSRM.G.markers.route.length; i<size; i++) {
+		if(OSRM.G.markers.route[i].label=='drag')
+			continue;
+		var position = OSRM.G.markers.route[i].getPosition();
+		var dist = OSRM.G.map.project(mouse).distanceTo(OSRM.G.map.project(position));
+		if( dist < 20 )
+			min_dist = 1000;
+	}
+	
+	// check whether mouse is over another marker
+	var pos = OSRM.G.map.layerPointToContainerPoint(event.layerPoint);
+	var obj = document.elementFromPoint(pos.x,pos.y);
+	for(var i=0, size=OSRM.G.markers.route.length; i<size; i++) {
+		if(OSRM.G.markers.route[i].label=='drag')
+			continue;
+		if( obj == OSRM.G.markers.route[i].marker._icon)
+			min_dist = 1000;
+	}
+	
+	// special care for highlight marker
+	if( OSRM.G.markers.highlight.isShown() ) {
+		if( OSRM.G.map.project(mouse).distanceTo(OSRM.G.map.project( OSRM.G.markers.highlight.getPosition() ) ) < 20 )
+			min_dist = 1000;
+		else if( obj == OSRM.G.markers.highlight.marker._icon)
+			min_dist = 1000;
+	}
+	
+	if( min_dist < 400) {
+		OSRM.G.markers.dragger.setPosition( OSRM.G.map.layerPointToLatLng(minpoint) );
+		OSRM.G.markers.dragger.show();
+	} else
+		OSRM.G.markers.dragger.hide();
+}
+
+};

WebContent/OSRM.base.js

@@ -0,0 +1,57 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM base class
+// [has to be loaded before all other OSRM classes]
+
+var OSRM = {};
+OSRM.VERSION = '0.1.3';
+OSRM.DATE = '120402';
+OSRM.CONSTANTS = {};
+OSRM.DEFAULTS = {};
+OSRM.GLOBALS = {};
+OSRM.G = OSRM.GLOBALS;		// abbreviations
+OSRM.C = OSRM.CONSTANTS;
+
+
+// declare one class to be a subclass of another class
+// (runs anonymous function to prevent local functions cluttering global namespace)
+(function() {
+var _inheritFromHelper = function() {};
+OSRM.inheritFrom = function( sub_class, base_class ) {
+	_inheritFromHelper.prototype = base_class.prototype;
+	sub_class.prototype = new _inheritFromHelper();
+	sub_class.prototype.constructor = sub_class;
+	sub_class.prototype.base = base_class.prototype;
+};
+}());
+
+
+// extend prototypes of a class -> used to add member values and functions
+OSRM.extend = function( target_class, properties ) {
+	for( property in properties ) {
+		target_class.prototype[property] = properties[property];
+	}
+};
+
+
+// [usage of convenience functions]
+// SubClass = function() {
+// 	SubClass.prototype.base.constructor.apply(this, arguments);
+// }
+// OSRM.inheritFrom( SubClass, BaseClass );
+// OSRM.extend( SubClass, { property:value } );

WebContent/OSRM.config.js

@@ -0,0 +1,36 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM config file
+// [has to be loaded directly after OSRM.base]
+
+OSRM.DEFAULTS = {
+	HOST_ROUTING_URL: 'http://router.project-osrm.org/viaroute',
+	HOST_SHORTENER_URL: 'http://map.project-osrm.org/shorten/',
+	HOST_GEOCODER_URL: 'http://nominatim.openstreetmap.org/search',
+	HOST_REVERSE_GEOCODER_URL: 'http://nominatim.openstreetmap.org/reverse',
+	WEBSITE_URL: document.URL.replace(/#*(\?.*|$)/i,""),					// truncates URL before first ?, and removes tailing #
+	JSONP_TIMEOUT: 5000,
+	ZOOM_LEVEL: 14,
+	ONLOAD_LATITUDE: 48.84,
+	ONLOAD_LONGITUDE: 10.10,
+	ONLOAD_SOURCE: "",
+	ONLOAD_TARGET: "",
+	HIGHLIGHT_ZOOM_LEVEL: 16,
+	LANGUAGE: "en",
+	GEOCODER_BOUNDS: '&bounded=1&viewbox=-27.0,72.0,46.0,36.0'
+};

WebContent/OSRM.debug.js

@@ -0,0 +1,66 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// debug code for OSRM
+// [works better than console.log in older browsers and for logging event handling]
+
+OSRM.debug = {};
+
+
+// access functions
+OSRM.debug.log = function(text) {
+	OSRM.debug.content.innerHTML += text + "<hr style='border:none; margin:2px; height:1px; color:#F0F0F0; background:#F0F0F0;'/>";
+	OSRM.debug.content.scrollTop = OSRM.debug.content.scrollHeight; 
+};
+OSRM.debug.clear = function() {
+	OSRM.debug.content.innerHTML = "";
+};	
+
+
+// add elements to DOM
+OSRM.debug.init = function() {
+	//create DOM objects for debug output
+	var wrapper = document.createElement('div');
+	wrapper.id = "OSRM.debug-wrapper";
+	wrapper.className = "gui-wrapper";
+	wrapper.style.cssText = "width:410px;height:95%;top:5px;right:50px;";
+
+	var box = document.createElement('div');
+	box.id = "OSRM.debug-box";
+	box.className = "gui-box";
+	box.style.cssText = "width:390px;top:0px;bottom:0px;";
+	
+	var clear = document.createElement('a');
+	clear.id = "OSRM.debug-clear";
+	clear.className = "button not-selectable";
+	clear.innerHTML = "clear";
+	clear.onclick = OSRM.debug.clear;
+
+	OSRM.debug.content= document.createElement('div');
+	OSRM.debug.content.id = "OSRM.debug-content";
+	OSRM.debug.content.style.cssText = "position:absolute;bottom:0px;top:20px;width:380px;font-size:11px;overflow:auto;margin:5px;";
+		
+	// add elements
+	document.body.appendChild(wrapper);
+	wrapper.appendChild(box);
+	box.appendChild(clear);
+	box.appendChild(OSRM.debug.content);
+};
+if(document.addEventListener)	// FF, CH
+	document.addEventListener("DOMContentLoaded", OSRM.debug.init, false);
+else	// IE
+	OSRM.debug.init();

WebContent/leaflet/leaflet.css

@@ -0,0 +1,323 @@
+/* required styles */
+
+.leaflet-map-pane,
+.leaflet-tile,
+.leaflet-marker-icon,
+.leaflet-marker-shadow,
+.leaflet-tile-pane,
+.leaflet-overlay-pane,
+.leaflet-shadow-pane,
+.leaflet-marker-pane,
+.leaflet-popup-pane,
+.leaflet-overlay-pane svg,
+.leaflet-zoom-box,
+.leaflet-image-layer { /* TODO optimize classes */
+	position: absolute;
+	}
+.leaflet-container {
+	overflow: hidden;
+	}
+.leaflet-tile-pane, .leaflet-container {
+	-webkit-transform: translate3d(0,0,0);
+	}
+.leaflet-tile,
+.leaflet-marker-icon,
+.leaflet-marker-shadow {
+	-moz-user-select: none;
+	-webkit-user-select: none;
+	user-select: none;
+	}
+.leaflet-marker-icon,
+.leaflet-marker-shadow {
+	display: block;
+	}
+.leaflet-clickable {
+	cursor: pointer;
+	}
+.leaflet-container img {
+	max-width: none !important;
+	}
+
+.leaflet-tile-pane { z-index: 2; }
+
+.leaflet-objects-pane { z-index: 3; }
+.leaflet-overlay-pane { z-index: 4; }
+.leaflet-shadow-pane { z-index: 5; }
+.leaflet-marker-pane { z-index: 6; }
+.leaflet-popup-pane { z-index: 7; }
+
+.leaflet-zoom-box {
+	width: 0;
+	height: 0;
+	}
+
+.leaflet-tile {
+	visibility: hidden;
+	}
+.leaflet-tile-loaded {
+	visibility: inherit;
+	}
+
+a.leaflet-active {
+	outline: 2px solid orange;
+	}
+
+
+/* Leaflet controls */
+
+.leaflet-control {
+	position: relative;
+	z-index: 7;
+	}
+.leaflet-top,
+.leaflet-bottom {
+	position: absolute;
+	}
+.leaflet-top {
+	top: 0;
+	}
+.leaflet-right {
+	right: 0;
+	}
+.leaflet-bottom {
+	bottom: 0;
+	}
+.leaflet-left {
+	left: 0;
+	}
+.leaflet-control {
+	float: left;
+	clear: both;
+	}
+.leaflet-right .leaflet-control {
+	float: right;
+	}
+.leaflet-top .leaflet-control {
+	margin-top: 10px;
+	}
+.leaflet-bottom .leaflet-control {
+	margin-bottom: 10px;
+	}
+.leaflet-left .leaflet-control {
+	margin-left: 10px;
+	}
+.leaflet-right .leaflet-control {
+	margin-right: 10px;
+	}
+
+.leaflet-control-zoom, .leaflet-control-layers {
+	-moz-border-radius: 7px;
+	-webkit-border-radius: 7px;
+	border-radius: 7px;
+	}
+.leaflet-control-zoom {
+	padding: 5px;
+	background: rgba(0, 0, 0, 0.25);
+	}
+.leaflet-control-zoom a {
+	background-color: rgba(255, 255, 255, 0.75);
+	}
+.leaflet-control-zoom a, .leaflet-control-layers a {
+	background-position: 50% 50%;
+	background-repeat: no-repeat;
+	display: block;
+	}
+.leaflet-control-zoom a {
+	-moz-border-radius: 4px;
+	-webkit-border-radius: 4px;
+	border-radius: 4px;
+	width: 19px;
+	height: 19px;
+	}
+.leaflet-control-zoom a:hover {
+	background-color: #fff;
+	}
+.leaflet-big-buttons .leaflet-control-zoom a {
+	width: 27px;
+	height: 27px;
+	}
+.leaflet-control-zoom-in {
+	background-image: url(images/zoom-in.png);
+	margin-bottom: 5px;
+	}
+.leaflet-control-zoom-out {
+	background-image: url(images/zoom-out.png);
+	}
+
+.leaflet-control-layers {
+	-moz-box-shadow: 0 0 7px #999;
+	-webkit-box-shadow: 0 0 7px #999;
+	box-shadow: 0 0 7px #999;
+
+	background: #f8f8f9;
+	}
+.leaflet-control-layers a {
+	background-image: url(images/layers.png);
+	width: 36px;
+	height: 36px;
+	}
+.leaflet-big-buttons .leaflet-control-layers a {
+	width: 44px;
+	height: 44px;
+	}
+.leaflet-control-layers .leaflet-control-layers-list,
+.leaflet-control-layers-expanded .leaflet-control-layers-toggle {
+	display: none;
+	}
+.leaflet-control-layers-expanded .leaflet-control-layers-list {
+	display: block;
+	position: relative;
+	}
+.leaflet-control-layers-expanded {
+	padding: 6px 10px 6px 6px;
+	font: 12px/1.5 "Helvetica Neue", Arial, Helvetica, sans-serif;
+	color: #333;
+	background: #fff;
+	}
+.leaflet-control-layers input {
+	margin-top: 2px;
+	position: relative;
+	top: 1px;
+	}
+.leaflet-control-layers label {
+	display: block;
+	}
+.leaflet-control-layers-separator {
+	height: 0;
+	border-top: 1px solid #ddd;
+	margin: 5px -10px 5px -6px;
+	}
+
+.leaflet-container .leaflet-control-attribution {
+	margin: 0;
+	padding: 0 5px;
+
+	font: 11px/1.5 "Helvetica Neue", Arial, Helvetica, sans-serif;
+	color: #333;
+
+	background-color: rgba(255, 255, 255, 0.7);
+
+	-moz-box-shadow: 0 0 7px #ccc;
+	-webkit-box-shadow: 0 0 7px #ccc;
+	box-shadow: 0 0 7px #ccc;
+	}
+
+
+/* Fade animations */
+
+.leaflet-fade-anim .leaflet-tile {
+	opacity: 0;
+
+	-webkit-transition: opacity 0.2s linear;
+	-moz-transition: opacity 0.2s linear;
+	-o-transition: opacity 0.2s linear;
+	transition: opacity 0.2s linear;
+	}
+.leaflet-fade-anim .leaflet-tile-loaded {
+	opacity: 1;
+	}
+
+.leaflet-fade-anim .leaflet-popup {
+	opacity: 0;
+
+	-webkit-transition: opacity 0.2s linear;
+	-moz-transition: opacity 0.2s linear;
+	-o-transition: opacity 0.2s linear;
+	transition: opacity 0.2s linear;
+	}
+.leaflet-fade-anim .leaflet-map-pane .leaflet-popup {
+	opacity: 1;
+	}
+
+.leaflet-zoom-anim .leaflet-tile {
+	-webkit-transition: none;
+	-moz-transition: none;
+	-o-transition: none;
+	transition: none;
+	}
+
+.leaflet-zoom-anim .leaflet-objects-pane {
+	visibility: hidden;
+	}
+
+
+/* Popup layout */
+
+.leaflet-popup {
+	position: absolute;
+	text-align: center;
+	-webkit-transform: translate3d(0,0,0);
+	}
+.leaflet-popup-content-wrapper {
+	padding: 1px;
+	text-align: left;
+	}
+.leaflet-popup-content {
+	margin: 19px;
+	}
+.leaflet-popup-tip-container {
+	margin: 0 auto;
+	width: 40px;
+	height: 16px;
+	position: relative;
+	overflow: hidden;
+	}
+.leaflet-popup-tip {
+	width: 15px;
+	height: 15px;
+	padding: 1px;
+
+	margin: -8px auto 0;
+
+	-moz-transform: rotate(45deg);
+	-webkit-transform: rotate(45deg);
+	-ms-transform: rotate(45deg);
+	-o-transform: rotate(45deg);
+	transform: rotate(45deg);
+	}
+.leaflet-popup-close-button {
+	position: absolute;
+	top: 9px;
+	right: 9px;
+
+	width: 10px;
+	height: 10px;
+
+	overflow: hidden;
+	}
+.leaflet-popup-content p {
+	margin: 18px 0;
+	}
+
+
+/* Visual appearance */
+
+.leaflet-container {
+	background: #ddd;
+	}
+.leaflet-container a {
+	color: #0078A8;
+	}
+.leaflet-zoom-box {
+	border: 2px dotted #05f;
+	background: white;
+	opacity: 0.5;
+	}
+.leaflet-popup-content-wrapper, .leaflet-popup-tip {
+	background: white;
+
+	box-shadow: 0 1px 10px #888;
+	-moz-box-shadow: 0 1px 10px #888;
+	 -webkit-box-shadow: 0 1px 14px #999;
+	}
+.leaflet-popup-content-wrapper {
+	-moz-border-radius: 20px;
+	-webkit-border-radius: 20px;
+	border-radius: 20px;
+	}
+.leaflet-popup-content {
+	font: 12px/1.4 "Helvetica Neue", Arial, Helvetica, sans-serif;
+	}
+.leaflet-popup-close-button {
+	background: white url(images/popup-close.png);
+	}

WebContent/leaflet/leaflet.ie.css

@@ -0,0 +1,48 @@
+.leaflet-tile {
+	filter: inherit;
+	}
+
+.leaflet-vml-shape {
+	width: 1px;
+	height: 1px;
+	}
+.lvml {
+	behavior: url(#default#VML); 
+	display: inline-block; 
+	position: absolute;
+	}
+	
+.leaflet-control {
+	display: inline;
+	}
+
+.leaflet-popup-tip {
+	width: 21px;
+	_width: 27px;
+	margin: 0 auto;
+	_margin-top: -3px;
+	
+	filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678);
+	-ms-filter: "progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)";
+	}
+.leaflet-popup-tip-container {
+	margin-top: -1px;
+	}
+.leaflet-popup-content-wrapper, .leaflet-popup-tip {
+	border: 1px solid #bbb;
+	}
+
+.leaflet-control-zoom {
+	filter: progid:DXImageTransform.Microsoft.gradient(startColorStr='#3F000000',EndColorStr='#3F000000');
+	}
+.leaflet-control-zoom a {
+	background-color: #eee;
+	}
+.leaflet-control-zoom a:hover {
+	background-color: #fff;
+	}
+.leaflet-control-layers-toggle {
+	}
+.leaflet-control-attribution, .leaflet-control-layers {
+	background: white;
+	}

WebContent/main.css

@@ -0,0 +1,370 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+/* OSRM CSS styles */
+
+
+/* map -> fullscreen */
+body {
+    padding: 0;
+    margin: 0;
+}
+html, body, #map {
+    height: 100%;
+}
+#map {
+	z-index: 0;
+}
+
+
+/* styles for gui */
+.vquad
+{
+	height:10px;
+}
+
+.gui-wrapper
+{
+	position:absolute;
+	border-radius:10px;
+	-moz-border-radius:10px;
+	-webkit-border-radius:10px;
+	background-color:#666666;
+	background-color:rgba(0, 0, 0, 0.25);
+	transition:left 1s;
+	-moz-transition:left 1s;
+	-webkit-transition:left 1s;
+	-o-transition:left 1s;
+	-ms-transition:left 1s;
+}
+.gui-box
+{
+	position:absolute;
+	background-color:#ffffff;	
+	background-color:rgba(255,255,255,1);
+	border-radius:10px;
+	-moz-border-radius:10px;
+	-webkit-border-radius:10px;	
+	margin:5px;
+	padding:5px;	
+}
+
+#main-wrapper
+{
+	width:410px;
+	height:95%;
+	top:5px;
+	left:5px;
+}
+#main-input
+{
+	width:390px;
+	height:200px;
+}
+#main-output
+{
+	width:390px;
+	top:220px;
+	bottom:0px;
+}
+
+#blob-wrapper
+{
+	left:-5px;
+	top:5px;
+	width:36px;
+	height:36px;
+	border-top-left-radius:0px;
+	border-bottom-left-radius:0px;
+	-moz-border-radius-topleft:0px;
+	-moz-border-radius-bottomleft:0px;
+	-webkit-border-top-left-radius:0px;
+	-webkit-border-bottom-left-radius:0px;
+	visibility:hidden;
+}
+#blob-input
+{
+	width:26px;
+	height:26px;
+	border-top-left-radius:0px;
+	border-bottom-left-radius:0px;
+	-moz-border-radius-topleft:0px;
+	-moz-border-radius-bottomleft:0px;
+	-webkit-border-top-left-radius:0px;
+	-webkit-border-bottom-left-radius:0px;	
+	padding:0px;
+}
+
+.main-toggle-out
+{
+	cursor:pointer;
+	position:absolute;
+	right:5px;
+	top:5px;
+	width:16px;
+	height:16px;
+	background-image:url("images/cancel.png");	
+}
+.main-toggle-out:hover
+{
+	background-image:url("images/cancel_hover.png");
+}
+.main-toggle-out:active
+{
+	background-image:url("images/cancel_active.png");
+}
+.main-toggle-in
+{
+	cursor:pointer;
+	position:absolute;
+	right:5px;
+	top:5px;
+	width:16px;
+	height:16px;
+	background-image:url("images/restore.png");	
+}
+.main-toggle-in:hover
+{
+	background-image:url("images/restore_hover.png");
+}
+.main-toggle-in:active
+{
+	background-image:url("images/restore_active.png");
+}
+
+.main-options
+{
+	position:relative;
+	font-size:10px;
+}
+.main-options-left-box
+{
+	position:absolute;
+	left:5px;
+	top:0px;
+}
+.main-options-right-box
+{
+	position:absolute;
+	right:5px;
+	top:5px;
+}
+#options-toggle
+{
+	cursor:pointer;
+	color:#0000ff
+}
+#options-toggle:hover
+{
+	color:#ff0000
+}
+#options-box
+{
+	visibility:hidden;
+}
+
+#osrm-logo
+{
+    display: block;
+    margin-left: auto;
+    margin-right: auto;
+    width: 192px;
+    height: 50px;
+	text-align:center;
+	vertical-align: middle;    
+}
+
+.input-box
+{
+	width: 250px;
+}
+
+
+.full
+{
+	width:100%;
+}
+.right
+{
+	text-align:right;
+}
+.center
+{
+	text-align:center;
+}
+
+#information-box
+{
+	position:absolute;
+	bottom:15px;
+	top:60px;
+	width:380px;
+	font-size:12px;
+	overflow:auto;
+	margin:5px;
+}
+
+.route-summary
+{
+	font-size: 12px;
+}
+#gpx-link
+{
+	color:#0000ff;
+	text-decoration:none;
+	cursor:pointer;
+}
+#gpx-link:hover
+{
+	color:#ff0000;
+}
+.results-table
+{
+	border-spacing:0px;
+}
+.results-odd
+{
+	background-color: #FAF3E9; //#ffffff;
+}
+.results-even
+{
+	background-color: #F2DE9C; //#ffffe0;
+}
+.result-counter
+{
+	text-align:right;
+	vertical-align: top;
+	width:30px;
+	font-weight:bold;
+	padding-left:5px;
+	padding-right:5px;
+	padding-top:1px;
+	padding-bottom:1px;
+}
+.result-items
+{
+	text-align:left;
+	vertical-align: middle;
+	width:100%;
+	padding-left:1px;
+	padding-right:1px;
+	padding-top:1px;
+	padding-bottom:1px;	
+}
+.result-direction
+{
+	width:30px;
+	padding-left:1px;
+	padding-right:1px;
+	padding-top:1px;
+	padding-bottom:1px;	
+}
+.result-distance
+{
+	text-align:right;
+	vertical-align: middle;	
+	width:30px;
+	padding-left:1px;
+	padding-right:1px;
+	padding-top:1px;
+	padding-bottom:1px;	
+}
+.result-item
+{
+	cursor:pointer;
+	color:#000000
+}
+.result-item:hover
+{
+	color:#ff0000
+}
+
+#legal-notice
+{
+	position:absolute;
+	right:0px;
+	bottom:0px;
+	padding:5px;
+	font-size:10px;
+}
+
+
+/* utility styles (defined above buttons, so that buttons retain cursor:pointer)*/
+.not-selectable
+{
+	cursor:default;
+	-moz-user-select: -moz-none;  
+	-webkit-user-select: none;  
+	-ms-user-select: none;
+	user-select: none;
+}
+
+.text-selectable
+{
+	cursor:default;
+	-moz-user-select: text;  
+	-webkit-user-select: text;  
+	-ms-user-select: text;
+	user-select: text;
+}
+
+
+/* buttons */
+.button
+{
+	cursor:pointer;
+	padding:2px 10px 2px 10px;
+	border-radius:5px;
+	-moz-border-radius:5px;
+	background-color:#EEEEEE;
+	border:1px solid #999999;
+	color:#333333;
+	text-decoration:none;
+	font-size:11px;
+	outline-style:none;  
+}
+.button:hover
+{
+	background-color:#F9F9F9;
+	color:#000000;
+}
+.button:active
+{
+	background-color:#F4F4F4;
+	color:#FF0000;
+}
+
+
+.delete-marker
+{
+	cursor:pointer;
+	position:absolute;
+	right:5px;
+	top:3px;
+	width:16px;
+	height:16px;
+	background-image:url("images/cancel.png");
+	visibility:hidden;	
+}
+.delete-marker:hover
+{
+	background-image:url("images/cancel_hover.png");
+}
+.delete-marker:active
+{
+	background-image:url("images/cancel_active.png");
+}

WebContent/main.html

@@ -0,0 +1,144 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<!--
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+-->
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+
+
+<!-- head -->
+<head>
+
+<!-- metatags -->
+<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
+<title>OSRM Website</title>
+<meta name="description" content="OSRM Website"/>
+<meta name="author" content="Dennis Schieferdecker" />
+
+<!--  favicon -->
+<link rel="shortcut icon" href="images/osrm-favicon.ico" type="image/x-icon" />
+
+<!-- stylesheets -->
+<link rel="stylesheet" href="leaflet/leaflet.css" type="text/css"/>
+<!--[if lte IE 8]><link rel="stylesheet" href="leaflet/leaflet.ie.css" type="text/css"/><![endif]-->
+<link rel="stylesheet" href="main.css" type="text/css"/>
+
+<!-- scripts -->
+<script src="leaflet/leaflet-src.js" type="text/javascript"></script>
+<script src="L.Bugfixes.js" type="text/javascript"></script>
+<script src="L.DashedPolyline.js" type="text/javascript"></script>
+<script src="L.MouseMarker.js" type="text/javascript"></script>
+<script src="L.SwitchableIcon.js" type="text/javascript"></script>
+
+<script src="OSRM.base.js" type="text/javascript"></script>
+<script src="OSRM.config.js" type="text/javascript"></script>
+<!-- <script defer="defer" src="OSRM.debug.js" type="text/javascript"></script> -->
+<script src="main.js" type="text/javascript"></script>
+
+<script src="OSRM.Markers.js" type="text/javascript"></script>
+<script src="OSRM.Route.js" type="text/javascript"></script>
+
+<script src="OSRM.Map.js" type="text/javascript"></script>
+<script src="OSRM.GUI.js" type="text/javascript"></script>
+<script src="routing/OSRM.Routing.js" type="text/javascript"></script>
+<script src="routing/OSRM.RoutingDescription.js" type="text/javascript"></script>
+<script src="routing/OSRM.RoutingGeometry.js" type="text/javascript"></script>
+<script src="routing/OSRM.RoutingGUI.js" type="text/javascript"></script>
+<script src="routing/OSRM.RoutingNoNames.js" type="text/javascript"></script>
+<script src="OSRM.Via.js" type="text/javascript"></script>
+<script src="OSRM.Geocoder.js" type="text/javascript"></script>
+
+<script src="OSRM.Browser.js" type="text/javascript"></script>
+<script src="OSRM.JSONP.js" type="text/javascript"></script>
+<script src="OSRM.Localization.js" type="text/javascript"></script>
+<script src="OSRM.Utils.js" type="text/javascript"></script>
+</head>
+
+
+<!-- body -->
+<body onload="OSRM.init();">
+
+<!--map-->
+<div id="map"></div>
+
+<!-- show ui blob -->
+<div id="blob-wrapper" class="gui-wrapper">
+<div id="blob-input" class="gui-box">
+   	<div class="main-toggle-in" onclick="OSRM.GUI.toggleMain()"></div>
+</div>
+</div>
+
+<!-- show main gui -->
+<div id="main-wrapper" class="gui-wrapper">
+
+<!-- input box -->
+<div class="gui-box not-selectable" id="main-input">
+	<div class="main-toggle-out" onclick="OSRM.GUI.toggleMain()"></div>
+	<img id="osrm-logo" alt="OSRM Logo" src="images/osrm-logo.png" />
+
+	<!-- source/target input -->
+    <table class="full">
+    <tr>
+    <td id="gui-search-source-label">Start:</td>
+    <td><div  style="position:relative;">
+    <input id="input-source-name" class="input-box" type="text" maxlength="200" value="" title="Startposition eingeben" onchange="OSRM.RoutingGUI.inputChanged(OSRM.C.SOURCE_LABEL);" />
+    <div id="delete-source-marker" class="delete-marker" onclick="OSRM.RoutingGUI.deleteMarker('source')"></div></div></td>
+    <td class="right"><a class="button not-selectable" id="gui-search-source" onclick="OSRM.RoutingGUI.showMarker('source')">Zeigen</a></td>
+    </tr>
+    
+    <tr>
+    <td id="gui-search-target-label">Ende:</td>
+    <td><div  style="position:relative;">
+    <input id="input-target-name" class="input-box" type="text" maxlength="200" value="" title="Zielposition eingeben" onchange="OSRM.RoutingGUI.inputChanged(OSRM.C.TARGET_LABEL);" />
+    <div id="delete-target-marker" class="delete-marker" onclick="OSRM.RoutingGUI.deleteMarker('target')"></div></div></td>
+	<td class="right"><a class="button not-selectable" id="gui-search-target" onclick="OSRM.RoutingGUI.showMarker('target');">Zeigen</a></td>	
+    </tr>
+    </table>
+    
+	<!-- action buttons -->
+    <div class="vquad"></div>
+    <table style="width:100%">
+    <tr>
+    <td>				<a class="button not-selectable" id="gui-reset" onclick="OSRM.RoutingGUI.resetRouting();">Reset</a></td>
+	<td class="right">	<a class="button not-selectable" id="gui-reverse" onclick="OSRM.RoutingGUI.reverseRouting();">Umdrehen</a></td>
+    </tr>
+    </table>
+    
+	<!-- options -->
+	<span class="main-options" id="options-toggle" onclick="OSRM.GUI.toggleOptions()">Kartenwerkzeuge</span>
+	<div class="main-options" id="options-box">
+	<span class="main-options-left-box">
+	<input type="checkbox" id="option-highlight-nonames" name="main-options" value="highlight-nonames" onclick="OSRM.Routing.getRoute();" /><span id="gui-option-highlight-nonames-label">Unbenannte Straßen hervorheben</span>
+	</span>
+	<span class="main-options-right-box">
+	<a class="button not-selectable" id="open-josm" onclick="OSRM.RoutingGUI.openJOSM();">JOSM</a>
+	<a class="button not-selectable" id="open-osmbugs" onclick="OSRM.RoutingGUI.openOSMBugs();">OSM Bugs</a>
+	</span>
+	</div>
+</div>
+
+<!-- output box -->
+<div class="gui-box not-selectable" id="main-output">
+	<div id="information-box-headline"></div>
+	<div id="information-box"></div>
+	<div id="legal-notice">GUI2 v0.1.1 120316 - OSRM hosting by <a href='http://algo2.iti.kit.edu/'>KIT</a> - Geocoder by <a href='http://www.osm.org/'>OSM</a></div>
+</div>
+
+</div>
+
+</body>
+</html>

WebContent/main.js

@@ -0,0 +1,183 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM initialization
+// [initialization, image prefetching]
+
+// will hold the Leaflet map object
+OSRM.GLOBALS.map = null;
+
+
+// onload initialization routine
+OSRM.init = function() {
+	OSRM.prefetchImages();
+	OSRM.prefetchIcons();
+	
+	OSRM.GUI.init();
+	OSRM.Map.init();
+	OSRM.Routing.init();	
+	
+ 	// check if the URL contains some GET parameter, e.g. for showing a route
+ 	OSRM.checkURL();
+};
+
+
+// prefetch images
+OSRM.GLOBALS.images = Array();
+OSRM.prefetchImages = function() {
+	var images = [	'images/marker-source.png',
+	              	'images/marker-target.png',
+	              	'images/marker-via.png',
+	              	'images/marker-highlight.png',
+	              	'images/marker-source-drag.png',
+	              	'images/marker-target-drag.png',
+	              	'images/marker-via-drag.png',
+	              	'images/marker-highlight-drag.png',
+	              	'images/marker-drag.png',
+	              	'images/cancel.png',
+	              	'images/cancel_active.png',
+	              	'images/cancel_hover.png',
+	              	'images/restore.png',
+	              	'images/restore_active.png',
+	              	'images/restore_hover.png'
+	              ];
+
+	for(var i=0; i<images.length; i++) {
+		OSRM.G.images[i] = new Image();
+		OSRM.G.images[i].src = images[i];
+	}
+};
+
+
+// prefetch icons
+OSRM.GLOBALS.icons = Array();
+OSRM.prefetchIcons = function() {
+	var images = [	'marker-source',
+	              	'marker-target',
+	              	'marker-via',
+	              	'marker-highlight',
+	              	'marker-source-drag',
+	              	'marker-target-drag',
+	              	'marker-via-drag',
+	              	'marker-highlight-drag',
+	              	'marker-drag'
+	              ];
+
+	for(var i=0; i<images.length; i++) {
+		var icon = {
+				iconUrl: 'images/'+images[i]+'.png', iconSize: new L.Point(25, 41), iconAnchor: new L.Point(13, 41),
+				shadowUrl: L.ROOT_URL + 'images/marker-shadow.png',	shadowSize: new L.Point(41, 41),
+				popupAnchor: new L.Point(0, -33)
+			};
+		OSRM.G.icons[images[i]] = new L.SwitchableIcon(icon);
+	}
+	
+	// special values for drag marker
+	OSRM.G.icons['marker-drag'] = new L.SwitchableIcon( {iconUrl: 'images/marker-drag.png', iconSize: new L.Point(18, 18) } );	
+};
+
+
+// parse URL GET parameters if any exist
+OSRM.checkURL = function(){
+	var called_url = document.location.search.substr(1,document.location.search.length);
+	
+	// reject messages that are clearly too long or too small 
+	if( called_url.length > 1000 || called_url.length == 0)
+		return;
+	
+	// storage for parameter values
+	var positions = [];
+	var zoom = null;
+	var center = null;
+	var destination = null;
+	var destination_name = null;
+
+	// parse input
+	var splitted_url = called_url.split('&');
+	for(var i=0; i<splitted_url.length; i++) {
+		var name_val = splitted_url[i].split('=');
+		if(name_val.length!=2)
+			continue;
+			
+		if(name_val[0] == 'loc') {
+			var coordinates = unescape(name_val[1]).split(',');
+			if(coordinates.length!=2 || !OSRM.Utils.isLatitude(coordinates[0]) || !OSRM.Utils.isLongitude(coordinates[1]) )
+				return;
+			positions.push ( new L.LatLng( coordinates[0], coordinates[1]) );
+		}
+		else if(name_val[0] == 'dest') {
+			var coordinates = unescape(name_val[1]).split(',');
+			if(coordinates.length!=2 || !OSRM.Utils.isLatitude(coordinates[0]) || !OSRM.Utils.isLongitude(coordinates[1]) )
+				return;				
+			destination = new L.LatLng( coordinates[0], coordinates[1]);
+		}
+		else if(name_val[0] == 'destname') {
+			destination_name = decodeURI(name_val[1]).replace(/<\/?[^>]+(>|$)/g ,"");	// discard tags	
+		}
+		else if(name_val[0] == 'z') {
+			zoom = name_val[1];
+			if( zoom<0 || zoom > 18)
+				return;
+		}
+		else if(name_val[0] == 'center') {
+			var coordinates = unescape(name_val[1]).split(',');
+			if(coordinates.length!=2 || !OSRM.Utils.isLatitude(coordinates[0]) || !OSRM.Utils.isLongitude(coordinates[1]) )
+				return;				
+			center = new L.LatLng( coordinates[0], coordinates[1]);			
+		}		
+	}
+		
+	// case 1: destination given
+	if( destination != undefined ) {
+		var index = OSRM.G.markers.setTarget( e.latlng );
+		if( destination_name == null )
+			OSRM.Geocoder.updateAddress( OSRM.C.TARGET_LABEL, OSRM.C.DO_FALLBACK_TO_LAT_LNG );
+		else 
+			document.getElementById("input-target-name").value = destination_name;
+		OSRM.G.markers.route[index].show();
+		OSRM.G.markers.route[index].centerView();
+		return;
+	}
+
+	// case 2: locations given
+	if( positions != []) {
+		// draw via points
+		if( positions.length > 0) {
+			OSRM.G.markers.setSource( positions[0] );
+			OSRM.Geocoder.updateAddress( OSRM.C.SOURCE_LABEL, OSRM.C.DO_FALLBACK_TO_LAT_LNG );
+		}
+		if(positions.length > 1) {
+			OSRM.G.markers.setTarget( positions[positions.length-1] );
+			OSRM.Geocoder.updateAddress( OSRM.C.TARGET_LABEL, OSRM.C.DO_FALLBACK_TO_LAT_LNG );
+		}
+		for(var i=1; i<positions.length-1;i++)
+			OSRM.G.markers.setVia( i-1, positions[i] );
+		for(var i=0; i<OSRM.G.markers.route.length;i++)
+			OSRM.G.markers.route[i].show();
+		
+		// center on route (support for old links) / move to given view (new behaviour)
+		if(zoom == null || center == null) {
+			var bounds = new L.LatLngBounds( positions );
+			OSRM.G.map.fitBoundsUI( bounds );
+		} else {
+			OSRM.G.map.setView(center, zoom);
+		}
+			
+		// compute route
+		OSRM.Routing.getRoute();
+	}
+};

WebContent/routing/OSRM.Routing.js

@@ -0,0 +1,148 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM routing
+// [management of routing requests and processing of responses]
+
+// some variables
+OSRM.GLOBALS.route = null;
+OSRM.GLOBALS.markers = null;
+
+OSRM.GLOBALS.dragging = null;
+OSRM.GLOBALS.dragid = null;
+OSRM.GLOBALS.pending = false;
+OSRM.GLOBALS.pendingTimer = null;
+
+
+OSRM.Routing = {
+		
+// init routing data structures
+init: function() {
+	OSRM.G.route = new OSRM.Route();
+	OSRM.G.markers = new OSRM.Markers();
+},
+
+
+// -- JSONP processing -- 
+
+// process JSONP response of routing server
+timeoutRouteSimple: function() {
+	OSRM.RoutingGeometry.showNA();
+	OSRM.RoutingDescription.showNA( OSRM.loc("TIMED_OUT") );
+},
+timeoutRoute: function() {
+	OSRM.RoutingGeometry.showNA();
+	OSRM.RoutingNoNames.showNA();
+	OSRM.RoutingDescription.showNA( OSRM.loc("TIMED_OUT") );
+},
+showRouteSimple: function(response) {
+ 	if(!response)
+ 		return;
+ 	if( !OSRM.G.dragging )		// prevent simple routing when no longer dragging
+ 		return;
+ 	
+	if( response.status == 207) {
+		OSRM.RoutingGeometry.showNA();
+		OSRM.RoutingDescription.showNA( OSRM.loc("YOUR_ROUTE_IS_BEING_COMPUTED") );
+	} else {
+		OSRM.RoutingGeometry.show(response);
+		OSRM.RoutingDescription.showSimple(response);
+	}
+	OSRM.Routing._updateHints(response);
+
+	if(OSRM.G.pending)
+		OSRM.G.pendingTimer = setTimeout(OSRM.Routing.draggingTimeout,1);		
+},
+showRoute: function(response) {
+	if(!response)
+		return;
+	
+	OSRM.G.via_points = response.via_points.slice(0);
+	if(response.status == 207) {
+		OSRM.RoutingGeometry.showNA();
+		OSRM.RoutingNoNames.showNA();
+		OSRM.RoutingDescription.showNA( OSRM.loc("NO_ROUTE_FOUND") );
+	} else {
+		OSRM.RoutingGeometry.show(response);
+		OSRM.RoutingNoNames.show(response);
+		OSRM.RoutingDescription.show(response);
+		OSRM.Routing._snapRoute();
+	}
+	OSRM.Routing._updateHints(response);
+},
+
+
+
+//-- main function --
+
+//generate server calls to query routes
+getRoute: function() {
+	
+	// if source or target are not set -> hide route
+	if( OSRM.G.markers.route.length < 2 ) {
+		OSRM.G.route.hideRoute();
+		return;
+	}
+	
+	OSRM.JSONP.call(OSRM.Routing._buildCall()+'&instructions=true', OSRM.Routing.showRoute, OSRM.Routing.timeoutRoute, OSRM.DEFAULTS.JSONP_TIMEOUT, 'route');
+},
+getDragRoute: function() {
+	OSRM.G.pending = !OSRM.JSONP.call(OSRM.Routing._buildCall()+'&instructions=false', OSRM.Routing.showRouteSimple, OSRM.Routing.timeoutRouteSimple, OSRM.DEFAULTS.JSONP_TIMEOUT, 'dragging');;
+},
+draggingTimeout: function() {
+	OSRM.G.markers.route[OSRM.G.dragid].hint = null;
+	OSRM.Routing.getDragRoute();
+},
+
+_buildCall: function() {
+	var source = OSRM.DEFAULTS.HOST_ROUTING_URL;
+	source += '?z=' + OSRM.G.map.getZoom() + '&output=json&geomformat=cmp';	
+	if(OSRM.G.markers.checksum)
+		source += '&checksum=' + OSRM.G.markers.checksum;
+	for(var i=0,size=OSRM.G.markers.route.length; i<size; i++) {
+		source += '&loc='  + OSRM.G.markers.route[i].getLat() + ',' + OSRM.G.markers.route[i].getLng();
+		if( OSRM.G.markers.route[i].hint)
+			source += '&hint=' + OSRM.G.markers.route[i].hint;
+	}
+	return source;
+},
+
+
+//-- helper functions --
+
+// update hints of all markers
+_updateHints: function(response) {
+	var hint_locations = response.hint_data.locations;
+	OSRM.G.markers.checksum = response.hint_data.checksum;
+	for(var i=0; i<hint_locations.length; i++)
+		OSRM.G.markers.route[i].hint = hint_locations[i];
+},
+
+// snap all markers to the received route
+_snapRoute: function() {
+	var positions = OSRM.G.route.getPositions();
+ 	
+ 	OSRM.G.markers.route[0].setPosition( positions[0] );
+ 	OSRM.G.markers.route[OSRM.G.markers.route.length-1].setPosition( positions[positions.length-1] );
+ 	for(var i=0; i<OSRM.G.via_points.length; i++)
+		OSRM.G.markers.route[i+1].setPosition( new L.LatLng(OSRM.G.via_points[i][0], OSRM.G.via_points[i][1]) );
+
+ 	OSRM.Geocoder.updateAddress(OSRM.C.SOURCE_LABEL);
+ 	OSRM.Geocoder.updateAddress(OSRM.C.TARGET_LABEL);
+}
+
+};

WebContent/routing/OSRM.RoutingDescription.js

@@ -0,0 +1,174 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM routing description
+// [renders routing description and manages events]
+
+
+OSRM.RoutingDescription = {
+		
+// route description events
+onClickRouteDescription: function(geometry_index) {
+	var positions = OSRM.G.route.getPositions();
+
+	OSRM.G.markers.highlight.setPosition( positions[geometry_index] );
+	OSRM.G.markers.highlight.show();
+	OSRM.G.markers.highlight.centerView(OSRM.DEFAULTS.HIGHLIGHT_ZOOM_LEVEL);	
+},
+onClickCreateShortcut: function(src){
+	src += '&z='+ OSRM.G.map.getZoom() + '&center=' + OSRM.G.map.getCenter().lat + ',' + OSRM.G.map.getCenter().lng;
+	OSRM.JSONP.call(OSRM.DEFAULTS.HOST_SHORTENER_URL+src, OSRM.RoutingDescription.showRouteLink, OSRM.RoutingDescription.showRouteLink_TimeOut, OSRM.DEFAULTS.JSONP_TIMEOUT, 'shortener');
+	document.getElementById('route-prelink').innerHTML = '['+OSRM.loc("GENERATE_LINK_TO_ROUTE")+']';
+},
+showRouteLink: function(response){
+	document.getElementById('route-prelink').innerHTML = '[<a id="gpx-link" class = "text-selectable" href="' +response.ShortURL+ '">'+response.ShortURL+'</a>]';
+// 	document.getElementById('route-prelink').innerHTML = '[<input class="text-selectable output-box" style="border:none" value="'+response.ShortURL+'" type="text" onfocus="this.select()" readonly="readonly"/>]';
+},
+showRouteLink_TimeOut: function(){
+	document.getElementById('route-prelink').innerHTML = '['+OSRM.loc("LINK_TO_ROUTE_TIMEOUT")+']';
+},
+
+// handling of routing description
+show: function(response) {
+	// compute query string
+	var query_string = '?rebuild=1';
+	for(var i=0; i<OSRM.G.markers.route.length; i++)
+		query_string += '&loc=' + OSRM.G.markers.route[i].getLat() + ',' + OSRM.G.markers.route[i].getLng(); 
+ 						
+	// create link to the route
+	var route_link ='<span class="route-summary" id="route-prelink">[<a id="gpx-link" onclick="OSRM.RoutingDescription.onClickCreateShortcut(\'' + OSRM.DEFAULTS.WEBSITE_URL + query_string + '\')">'+OSRM.loc("GET_LINK_TO_ROUTE")+'</a>]</span>';
+
+	// create GPX link
+	var gpx_link = '<span class="route-summary">[<a id="gpx-link" onClick="document.location.href=\'' + OSRM.DEFAULTS.HOST_ROUTING_URL + query_string + '&output=gpx\';">'+OSRM.loc("GPX_FILE")+'</a>]</span>';
+		
+	// create route description
+	var route_desc = "";
+	route_desc += '<table class="results-table">';
+
+	for(var i=0; i < response.route_instructions.length; i++){
+		//odd or even ?
+		var rowstyle='results-odd';
+		if(i%2==0) { rowstyle='results-even'; }
+
+		route_desc += '<tr class="'+rowstyle+'">';
+		
+		route_desc += '<td class="result-directions">';
+		route_desc += '<img width="18px" src="images/'+OSRM.RoutingDescription.getDirectionIcon(response.route_instructions[i][0])+'" alt="" />';
+		route_desc += "</td>";		
+		
+		route_desc += '<td class="result-items">';
+		route_desc += '<span class="result-item" onclick="OSRM.RoutingDescription.onClickRouteDescription('+response.route_instructions[i][3]+')">';
+		route_desc += response.route_instructions[i][0];
+		if( i == 0 )
+			route_desc += ' ' + OSRM.loc( response.route_instructions[i][6] );		
+		if( response.route_instructions[i][1] != "" ) {
+			route_desc += ' on ';
+			route_desc += '<b>' + response.route_instructions[i][1] + '</b>';
+		}
+		//route_desc += ' for ';
+		route_desc += '</span>';
+		route_desc += "</td>";
+		
+		route_desc += '<td class="result-distance">';
+		if( i != response.route_instructions.length-1 )
+		route_desc += '<b>'+OSRM.Utils.metersToDistance(response.route_instructions[i][2])+'</b>';
+		route_desc += "</td>";
+		
+		route_desc += "</tr>";
+	}	
+		
+	route_desc += '</table>';		
+	headline = "";
+	headline += OSRM.loc("ROUTE_DESCRIPTION")+":<br>";
+	headline += '<div style="float:left;width:40%">';
+	headline += "<span class='route-summary'>"
+		+ OSRM.loc("DISTANCE")+": " + OSRM.Utils.metersToDistance(response.route_summary.total_distance)
+		+ "<br>"
+		+ OSRM.loc("DURATION")+": " + OSRM.Utils.secondsToTime(response.route_summary.total_time)
+		+ "</span>";		
+	headline +=	'</div>';
+	headline += '<div style="float:left;text-align:right;width:60%;">'+route_link+'<br>'+gpx_link+'</div>';
+
+	var output = "";
+	output += route_desc;
+
+	document.getElementById('information-box-headline').innerHTML = headline;
+	document.getElementById('information-box').innerHTML = output;
+},
+
+// simple description
+showSimple: function(response) {
+	headline = OSRM.loc("ROUTE_DESCRIPTION")+":<br>";
+	headline += "<span class='route-summary'>"
+			+ OSRM.loc("DISTANCE")+": " + OSRM.Utils.metersToDistance(response.route_summary.total_distance)
+			+ "<br>"
+			+ OSRM.loc("DURATION")+": " + OSRM.Utils.secondsToTime(response.route_summary.total_time)
+			+ "</span>";
+	headline += '<br><br>';
+
+	document.getElementById('information-box-headline').innerHTML = headline;
+	document.getElementById('information-box').innerHTML = "<br><p style='font-size:14px;font-weight:bold;text-align:center;'>"+OSRM.loc("YOUR_ROUTE_IS_BEING_COMPUTED")+".<p>";	
+},
+
+// no description
+showNA: function( display_text ) {
+	headline = OSRM.loc("ROUTE_DESCRIPTION")+":<br>";
+	headline += "<span class='route-summary'>"
+			+ OSRM.loc("DISTANCE")+": N/A"
+			+ "<br>"
+			+ OSRM.loc("DURATION")+": N/A"
+			+ "</span>";
+	headline += '<br><br>';
+
+	document.getElementById('information-box-headline').innerHTML = headline;
+	document.getElementById('information-box').innerHTML = "<br><p style='font-size:14px;font-weight:bold;text-align:center;'>"+display_text+".<p>";	
+},
+
+// map driving instructions to icons
+// [TODO: language-safe implementation]
+getDirectionIcon: function(name) {
+	var directions = {
+		"Turn left":"turn-left.png",
+		"Turn right":"turn-right.png",
+		"U-Turn":"u-turn.png",
+		"Head":"continue.png",
+		"Continue":"continue.png",
+		"Turn slight left":"slight-left.png",
+		"Turn slight right":"slight-right.png",
+		"Turn sharp left":"sharp-left.png",
+		"Turn sharp right":"sharp-right.png",
+		"Enter roundabout and leave at first exit":"round-about.png",
+		"Enter roundabout and leave at second exit":"round-about.png",
+		"Enter roundabout and leave at third exit":"round-about.png",
+		"Enter roundabout and leave at fourth exit":"round-about.png",
+		"Enter roundabout and leave at fifth exit":"round-about.png",
+		"Enter roundabout and leave at sixth exit":"round-about.png",
+		"Enter roundabout and leave at seventh exit":"round-about.png",
+		"Enter roundabout and leave at eighth exit":"round-about.png",
+		"Enter roundabout and leave at nineth exit":"round-about.png",
+		"Enter roundabout and leave at tenth exit":"round-about.png",
+		"Enter roundabout and leave at one of the too many exit":"round-about.png",
+		"You have reached your destination":"target.png"
+	};
+	
+	if( directions[name] )
+		return directions[name];
+	else
+		return "default.png";
+}
+
+};

WebContent/routing/OSRM.RoutingGUI.js

@@ -0,0 +1,129 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM routing
+// [handles GUI events]
+
+
+OSRM.RoutingGUI = {
+
+// click: button "reset"
+resetRouting: function() {
+	document.getElementById('input-source-name').value = "";
+	document.getElementById('input-target-name').value = "";
+	
+	OSRM.G.route.hideAll();
+	OSRM.G.markers.removeAll();
+	OSRM.G.markers.highlight.hide();
+	
+	document.getElementById('information-box').innerHTML = "";
+	document.getElementById('information-box-headline').innerHTML = "";
+	
+	OSRM.JSONP.reset();	
+},
+
+// click: button "reverse"
+reverseRouting: function() {
+	// invert input boxes
+	var tmp = document.getElementById("input-source-name").value;
+	document.getElementById("input-source-name").value = document.getElementById("input-target-name").value;
+	document.getElementById("input-target-name").value = tmp;
+	
+	// invert route
+	OSRM.G.markers.route.reverse();
+	if(OSRM.G.markers.route.length == 1) {
+		if(OSRM.G.markers.route[0].label == OSRM.C.TARGET_LABEL) {
+			OSRM.G.markers.route[0].label = OSRM.C.SOURCE_LABEL;
+			OSRM.G.markers.route[0].marker.setIcon( new L.Icon('images/marker-source.png') );
+		} else if(OSRM.G.markers.route[0].label == OSRM.C.SOURCE_LABEL) {
+			OSRM.G.markers.route[0].label = OSRM.C.TARGET_LABEL;
+			OSRM.G.markers.route[0].marker.setIcon( new L.Icon('images/marker-target.png') );
+		}
+	} else if(OSRM.G.markers.route.length > 1){
+		OSRM.G.markers.route[0].label = OSRM.C.SOURCE_LABEL;
+		OSRM.G.markers.route[0].marker.setIcon( new L.Icon('images/marker-source.png') );
+		
+		OSRM.G.markers.route[OSRM.G.markers.route.length-1].label = OSRM.C.TARGET_LABEL;
+		OSRM.G.markers.route[OSRM.G.markers.route.length-1].marker.setIcon( new L.Icon('images/marker-target.png') );		
+	}
+	
+	// recompute route
+	if( OSRM.G.route.isShown() ) {
+		OSRM.Routing.getRoute();
+		OSRM.G.markers.highlight.hide();
+	} else {
+		document.getElementById('information-box').innerHTML = "";
+		document.getElementById('information-box-headline').innerHTML = "";		
+	}
+},
+
+// click: button "show"
+showMarker: function(marker_id) {
+	if( OSRM.JSONP.fences["geocoder_source"] || OSRM.JSONP.fences["geocoder_target"] )
+		return;
+	
+	if( marker_id == OSRM.C.SOURCE_LABEL && OSRM.G.markers.hasSource() )
+		OSRM.G.markers.route[0].centerView();
+	else if( marker_id == OSRM.C.TARGET_LABEL && OSRM.G.markers.hasTarget() )
+		OSRM.G.markers.route[OSRM.G.markers.route.length-1].centerView();
+},
+
+
+// changed: any inputbox (is called when return is pressed [after] or focus is lost [before])
+inputChanged: function(marker_id) {
+	if( marker_id == OSRM.C.SOURCE_LABEL)	
+		OSRM.Geocoder.call(OSRM.C.SOURCE_LABEL, document.getElementById('input-source-name').value);
+	else if( marker_id == OSRM.C.TARGET_LABEL)
+		OSRM.Geocoder.call(OSRM.C.TARGET_LABEL, document.getElementById('input-target-name').value);
+},
+
+// click: button "open JOSM"
+openJOSM: function() {
+	var x = OSRM.G.map.getCenterUI();
+	var ydelta = 0.01;
+	var xdelta = ydelta * 2;
+	var p = [ 'left='  + (x.lng - xdelta), 'bottom=' + (x.lat - ydelta), 'right=' + (x.lng + xdelta), 'top='    + (x.lat + ydelta)];
+	var url = 'http://localhost:8111/load_and_zoom?' + p.join('&');
+	
+	var frame = L.DomUtil.create('iframe', null, document.body);
+	frame.style.width = frame.style.height = "0px";
+	frame.src = url;
+	frame.onload = function(e) { document.body.removeChild(frame); };
+},
+
+//click: button "open OSM Bugs"
+openOSMBugs: function() {
+	var position = OSRM.G.map.getCenterUI();
+	window.open( "http://osmbugs.org/?lat="+position.lat.toFixed(6)+"&lon="+position.lng.toFixed(6)+"&zoom="+OSRM.G.map.getZoom() );
+},
+
+//click: button "delete marker"
+deleteMarker: function(marker_id) {
+	var id = null;
+	if(marker_id == 'source' && OSRM.G.markers.hasSource() )
+		id = 0;
+	else if(marker_id == 'target' && OSRM.G.markers.hasTarget() )
+		id = OSRM.G.markers.route.length-1;
+	if( id == null)
+		return;
+	
+	OSRM.G.markers.removeMarker( id );
+	OSRM.Routing.getRoute();
+	OSRM.G.markers.highlight.hide();	
+}
+
+};

WebContent/routing/OSRM.RoutingGeometry.js

@@ -0,0 +1,71 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM routing geometry
+// [renders routing geometry]
+
+
+OSRM.RoutingGeometry = {
+
+// show route geometry - if there is a route
+show: function(response) {
+	var geometry = OSRM.RoutingGeometry._decode(response.route_geometry, 5);
+
+	var positions = [];
+	for( var i=0, size=geometry.length; i < size; i++)
+		positions.push( new L.LatLng(geometry[i][0], geometry[i][1]) );
+	
+	OSRM.G.route.showRoute(positions, OSRM.Route.ROUTE);
+},
+
+//show route geometry - if there is no route
+showNA: function() {
+	var positions = [];
+	for(var i=0, size=OSRM.G.markers.route.length; i<size; i++)
+			positions.push( OSRM.G.markers.route[i].getPosition() );
+
+	OSRM.G.route.showRoute(positions, OSRM.Route.NOROUTE);
+},
+
+//decode compressed route geometry
+_decode: function(encoded, precision) {
+	precision = Math.pow(10, -precision);
+	var len = encoded.length, index=0, lat=0, lng = 0, array = [];
+	while (index < len) {
+		var b, shift = 0, result = 0;
+		do {
+			b = encoded.charCodeAt(index++) - 63;
+			result |= (b & 0x1f) << shift;
+			shift += 5;
+		} while (b >= 0x20);
+		var dlat = ((result & 1) ? ~(result >> 1) : (result >> 1));
+		lat += dlat;
+		shift = 0;
+		result = 0;
+		do {
+			b = encoded.charCodeAt(index++) - 63;
+			result |= (b & 0x1f) << shift;
+			shift += 5;
+		} while (b >= 0x20);
+		var dlng = ((result & 1) ? ~(result >> 1) : (result >> 1));
+		lng += dlng;
+		array.push([lat * precision, lng * precision]);
+	}
+	return array;
+}
+
+};

WebContent/routing/OSRM.RoutingNoNames.js

@@ -0,0 +1,68 @@
+/*
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+// OSRM routing
+// [renders route segments that are unnamed streets]
+
+
+OSRM.RoutingNoNames = {
+		
+// displays route segments that are unnamed streets
+show: function(response) {
+	// do not display unnamed streets?
+	if( document.getElementById('option-highlight-nonames').checked == false) {
+		OSRM.G.route.hideUnnamedRoute();
+		return;
+	}
+		
+	// mark geometry positions where unnamed/named streets switch
+	var named = [];
+	for (var i = 0; i < response.route_instructions.length; i++) {
+		if( response.route_instructions[i][1] == '' )
+			named[ response.route_instructions[i][3] ] = false;		// no street name
+		else
+			named[ response.route_instructions[i][3] ] = true;		// yes street name
+	}
+
+	// aggregate geometry for unnamed streets
+	var geometry = OSRM.RoutingGeometry._decode(response.route_geometry, 5);
+	var is_named = true;
+	var current_positions = [];
+	var all_positions = [];
+	for( var i=0; i < geometry.length; i++) {
+		current_positions.push( new L.LatLng(geometry[i][0], geometry[i][1]) );
+
+		// still named/unnamed?
+		if( (named[i] == is_named || named[i] == undefined) && i != geometry.length-1 )
+			continue;
+
+		// switch between named/unnamed!
+		if(is_named == false)
+			all_positions.push( current_positions );
+		current_positions = [];
+		current_positions.push( new L.LatLng(geometry[i][0], geometry[i][1]) );
+		is_named = named[i];
+	}
+	
+	// display unnamed streets
+	OSRM.G.route.showUnnamedRoute(all_positions);
+},
+
+showNA: function() {
+	OSRM.G.route.hideUnnamedRoute();	
+}
+};

algorithms/bayes_classifier.hpp

@@ -1,118 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef BAYES_CLASSIFIER_HPP
-#define BAYES_CLASSIFIER_HPP
-
-#include <cmath>
-
-#include <vector>
-#include <utility>
-
-struct NormalDistribution
-{
-    NormalDistribution(const double mean, const double standard_deviation)
-        : mean(mean), standard_deviation(standard_deviation)
-    {
-    }
-
-    // FIXME implement log-probability version since its faster
-    double density_function(const double val) const
-    {
-        const double x = val - mean;
-        return 1.0 / (std::sqrt(2. * M_PI) * standard_deviation) *
-               std::exp(-x * x / (standard_deviation * standard_deviation));
-    }
-
-    double mean;
-    double standard_deviation;
-};
-
-struct LaplaceDistribution
-{
-    LaplaceDistribution(const double location, const double scale)
-        : location(location), scale(scale)
-    {
-    }
-
-    // FIXME implement log-probability version since its faster
-    double density_function(const double val) const
-    {
-        const double x = std::abs(val - location);
-        return 1.0 / (2. * scale) * std::exp(-x / scale);
-    }
-
-    double location;
-    double scale;
-};
-
-template <typename PositiveDistributionT, typename NegativeDistributionT, typename ValueT>
-class BayesClassifier
-{
-  public:
-    enum class ClassLabel : unsigned
-    {
-        NEGATIVE,
-        POSITIVE
-    };
-    using ClassificationT = std::pair<ClassLabel, double>;
-
-    BayesClassifier(PositiveDistributionT positive_distribution,
-                    NegativeDistributionT negative_distribution,
-                    const double positive_apriori_probability)
-        : positive_distribution(std::move(positive_distribution)),
-          negative_distribution(std::move(negative_distribution)),
-          positive_apriori_probability(positive_apriori_probability),
-          negative_apriori_probability(1. - positive_apriori_probability)
-    {
-    }
-
-    // Returns label and the probability of the label.
-    ClassificationT classify(const ValueT &v) const
-    {
-        const double positive_postpriori =
-            positive_apriori_probability * positive_distribution.density_function(v);
-        const double negative_postpriori =
-            negative_apriori_probability * negative_distribution.density_function(v);
-        const double norm = positive_postpriori + negative_postpriori;
-
-        if (positive_postpriori > negative_postpriori)
-        {
-            return std::make_pair(ClassLabel::POSITIVE, positive_postpriori / norm);
-        }
-
-        return std::make_pair(ClassLabel::NEGATIVE, negative_postpriori / norm);
-    }
-
-  private:
-    PositiveDistributionT positive_distribution;
-    NegativeDistributionT negative_distribution;
-    double positive_apriori_probability;
-    double negative_apriori_probability;
-};
-
-#endif // BAYES_CLASSIFIER_HPP

algorithms/bfs_components.hpp

@@ -1,174 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef BFS_COMPONENTS_HPP_
-#define BFS_COMPONENTS_HPP_
-
-#include "../typedefs.h"
-#include "../data_structures/restriction_map.hpp"
-
-#include <queue>
-#include <unordered_set>
-
-// Explores the components of the given graph while respecting turn restrictions
-// and barriers.
-template <typename GraphT> class BFSComponentExplorer
-{
-  public:
-    BFSComponentExplorer(const GraphT &dynamic_graph,
-                         const RestrictionMap &restrictions,
-                         const std::unordered_set<NodeID> &barrier_nodes)
-        : m_graph(dynamic_graph), m_restriction_map(restrictions), m_barrier_nodes(barrier_nodes)
-    {
-        BOOST_ASSERT(m_graph.GetNumberOfNodes() > 0);
-    }
-
-    /*!
-     * Returns the size of the component that the node belongs to.
-     */
-    unsigned int GetComponentSize(const NodeID node) const
-    {
-        BOOST_ASSERT(node < m_component_index_list.size());
-
-        return m_component_index_size[m_component_index_list[node]];
-    }
-
-    unsigned int GetNumberOfComponents() { return m_component_index_size.size(); }
-
-    /*!
-     * Computes the component sizes.
-     */
-    void run()
-    {
-        std::queue<std::pair<NodeID, NodeID>> bfs_queue;
-        unsigned current_component = 0;
-
-        BOOST_ASSERT(m_component_index_list.empty());
-        BOOST_ASSERT(m_component_index_size.empty());
-
-        unsigned num_nodes = m_graph.GetNumberOfNodes();
-
-        m_component_index_list.resize(num_nodes, std::numeric_limits<unsigned>::max());
-
-        BOOST_ASSERT(num_nodes > 0);
-
-        // put unexplorered node with parent pointer into queue
-        for (NodeID node = 0; node < num_nodes; ++node)
-        {
-            if (std::numeric_limits<unsigned>::max() == m_component_index_list[node])
-            {
-                unsigned size = ExploreComponent(bfs_queue, node, current_component);
-
-                // push size into vector
-                m_component_index_size.emplace_back(size);
-                ++current_component;
-            }
-        }
-    }
-
-  private:
-    /*!
-     * Explores the current component that starts at node using BFS.
-     */
-    unsigned ExploreComponent(std::queue<std::pair<NodeID, NodeID>> &bfs_queue,
-                              NodeID node,
-                              unsigned current_component)
-    {
-        /*
-           Graphical representation of variables:
-
-           u           v           w
-           *---------->*---------->*
-                            e2
-        */
-
-        bfs_queue.emplace(node, node);
-        // mark node as read
-        m_component_index_list[node] = current_component;
-
-        unsigned current_component_size = 1;
-
-        while (!bfs_queue.empty())
-        {
-            // fetch element from BFS queue
-            std::pair<NodeID, NodeID> current_queue_item = bfs_queue.front();
-            bfs_queue.pop();
-
-            const NodeID v = current_queue_item.first;  // current node
-            const NodeID u = current_queue_item.second; // parent
-            // increment size counter of current component
-            ++current_component_size;
-            if (m_barrier_nodes.find(v) != m_barrier_nodes.end())
-            {
-                continue;
-            }
-            const NodeID to_node_of_only_restriction =
-                m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v);
-
-            for (auto e2 : m_graph.GetAdjacentEdgeRange(v))
-            {
-                const NodeID w = m_graph.GetTarget(e2);
-
-                if (to_node_of_only_restriction != std::numeric_limits<unsigned>::max() &&
-                    w != to_node_of_only_restriction)
-                {
-                    // At an only_-restriction but not at the right turn
-                    continue;
-                }
-
-                if (u != w)
-                {
-                    // only add an edge if turn is not a U-turn except
-                    // when it is at the end of a dead-end street.
-                    if (!m_restriction_map.CheckIfTurnIsRestricted(u, v, w))
-                    {
-                        // only add an edge if turn is not prohibited
-                        if (std::numeric_limits<unsigned>::max() == m_component_index_list[w])
-                        {
-                            // insert next (node, parent) only if w has
-                            // not yet been explored
-                            // mark node as read
-                            m_component_index_list[w] = current_component;
-                            bfs_queue.emplace(w, v);
-                        }
-                    }
-                }
-            }
-        }
-
-        return current_component_size;
-    }
-
-    std::vector<unsigned> m_component_index_list;
-    std::vector<NodeID> m_component_index_size;
-
-    const GraphT &m_graph;
-    const RestrictionMap &m_restriction_map;
-    const std::unordered_set<NodeID> &m_barrier_nodes;
-};
-
-#endif // BFS_COMPONENTS_HPP_

algorithms/coordinate_calculation.cpp

@@ -1,273 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#include "coordinate_calculation.hpp"
-
-#include "../util/mercator.hpp"
-#include "../util/string_util.hpp"
-
-#include <boost/assert.hpp>
-
-#include <osrm/coordinate.hpp>
-
-#include <cmath>
-
-#include <limits>
-
-namespace
-{
-constexpr static const float RAD = 0.017453292519943295769236907684886f;
-// earth radius varies between 6,356.750-6,378.135 km (3,949.901-3,963.189mi)
-// The IUGG value for the equatorial radius is 6378.137 km (3963.19 miles)
-constexpr static const float earth_radius = 6372797.560856f;
-}
-
-namespace coordinate_calculation
-{
-
-double haversine_distance(const int lat1,
-                                                     const int lon1,
-                                                     const int lat2,
-                                                     const int lon2)
-{
-    BOOST_ASSERT(lat1 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lon1 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lat2 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lon2 != std::numeric_limits<int>::min());
-    const double lt1 = lat1 / COORDINATE_PRECISION;
-    const double ln1 = lon1 / COORDINATE_PRECISION;
-    const double lt2 = lat2 / COORDINATE_PRECISION;
-    const double ln2 = lon2 / COORDINATE_PRECISION;
-    const double dlat1 = lt1 * (RAD);
-
-    const double dlong1 = ln1 * (RAD);
-    const double dlat2 = lt2 * (RAD);
-    const double dlong2 = ln2 * (RAD);
-
-    const double dLong = dlong1 - dlong2;
-    const double dLat = dlat1 - dlat2;
-
-    const double aHarv = std::pow(std::sin(dLat / 2.0), 2.0) +
-                         std::cos(dlat1) * std::cos(dlat2) * std::pow(std::sin(dLong / 2.), 2);
-    const double cHarv = 2. * std::atan2(std::sqrt(aHarv), std::sqrt(1.0 - aHarv));
-    return earth_radius * cHarv;
-}
-
-double haversine_distance(const FixedPointCoordinate &coordinate_1,
-                                                     const FixedPointCoordinate &coordinate_2)
-{
-    return haversine_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
-                                 coordinate_2.lon);
-}
-
-float great_circle_distance(const FixedPointCoordinate &coordinate_1,
-                                                 const FixedPointCoordinate &coordinate_2)
-{
-    return great_circle_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
-                              coordinate_2.lon);
-}
-
-float great_circle_distance(const int lat1,
-                                                 const int lon1,
-                                                 const int lat2,
-                                                 const int lon2)
-{
-    BOOST_ASSERT(lat1 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lon1 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lat2 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lon2 != std::numeric_limits<int>::min());
-
-    const float float_lat1 = (lat1 / COORDINATE_PRECISION) * RAD;
-    const float float_lon1 = (lon1 / COORDINATE_PRECISION) * RAD;
-    const float float_lat2 = (lat2 / COORDINATE_PRECISION) * RAD;
-    const float float_lon2 = (lon2 / COORDINATE_PRECISION) * RAD;
-
-    const float x_value = (float_lon2 - float_lon1) * std::cos((float_lat1 + float_lat2) / 2.f);
-    const float y_value = float_lat2 - float_lat1;
-    return std::hypot(x_value, y_value) * earth_radius;
-}
-
-float perpendicular_distance(const FixedPointCoordinate &source_coordinate,
-                                                     const FixedPointCoordinate &target_coordinate,
-                                                     const FixedPointCoordinate &query_location)
-{
-    float ratio;
-    FixedPointCoordinate nearest_location;
-
-    return perpendicular_distance(source_coordinate, target_coordinate, query_location,
-                                  nearest_location, ratio);
-}
-
-float perpendicular_distance(const FixedPointCoordinate &segment_source,
-                                                     const FixedPointCoordinate &segment_target,
-                                                     const FixedPointCoordinate &query_location,
-                                                     FixedPointCoordinate &nearest_location,
-                                                     float &ratio)
-{
-    return perpendicular_distance_from_projected_coordinate(
-        segment_source, segment_target, query_location,
-        {mercator::lat2y(query_location.lat / COORDINATE_PRECISION),
-         query_location.lon / COORDINATE_PRECISION},
-        nearest_location, ratio);
-}
-
-float perpendicular_distance_from_projected_coordinate(
-    const FixedPointCoordinate &source_coordinate,
-    const FixedPointCoordinate &target_coordinate,
-    const FixedPointCoordinate &query_location,
-    const std::pair<double, double> &projected_coordinate)
-{
-    float ratio;
-    FixedPointCoordinate nearest_location;
-
-    return perpendicular_distance_from_projected_coordinate(source_coordinate, target_coordinate,
-                                                            query_location, projected_coordinate,
-                                                            nearest_location, ratio);
-}
-
-float perpendicular_distance_from_projected_coordinate(
-    const FixedPointCoordinate &segment_source,
-    const FixedPointCoordinate &segment_target,
-    const FixedPointCoordinate &query_location,
-    const std::pair<double, double> &projected_coordinate,
-    FixedPointCoordinate &nearest_location,
-    float &ratio)
-{
-    BOOST_ASSERT(query_location.is_valid());
-
-    // initialize values
-    const double x = projected_coordinate.first;
-    const double y = projected_coordinate.second;
-    const double a = mercator::lat2y(segment_source.lat / COORDINATE_PRECISION);
-    const double b = segment_source.lon / COORDINATE_PRECISION;
-    const double c = mercator::lat2y(segment_target.lat / COORDINATE_PRECISION);
-    const double d = segment_target.lon / COORDINATE_PRECISION;
-    double p, q /*,mX*/, nY;
-    if (std::abs(a - c) > std::numeric_limits<double>::epsilon())
-    {
-        const double m = (d - b) / (c - a); // slope
-        // Projection of (x,y) on line joining (a,b) and (c,d)
-        p = ((x + (m * y)) + (m * m * a - m * b)) / (1.f + m * m);
-        q = b + m * (p - a);
-    }
-    else
-    {
-        p = c;
-        q = y;
-    }
-    nY = (d * p - c * q) / (a * d - b * c);
-
-    // discretize the result to coordinate precision. it's a hack!
-    if (std::abs(nY) < (1.f / COORDINATE_PRECISION))
-    {
-        nY = 0.f;
-    }
-
-    // compute ratio
-    ratio =
-        static_cast<float>((p - nY * a) / c); // These values are actually n/m+n and m/m+n , we need
-    // not calculate the explicit values of m an n as we
-    // are just interested in the ratio
-    if (std::isnan(ratio))
-    {
-        ratio = (segment_target == query_location ? 1.f : 0.f);
-    }
-    else if (std::abs(ratio) <= std::numeric_limits<float>::epsilon())
-    {
-        ratio = 0.f;
-    }
-    else if (std::abs(ratio - 1.f) <= std::numeric_limits<float>::epsilon())
-    {
-        ratio = 1.f;
-    }
-
-    // compute nearest location
-    BOOST_ASSERT(!std::isnan(ratio));
-    if (ratio <= 0.f)
-    {
-        nearest_location = segment_source;
-    }
-    else if (ratio >= 1.f)
-    {
-        nearest_location = segment_target;
-    }
-    else
-    {
-        // point lies in between
-        nearest_location.lat = static_cast<int>(mercator::y2lat(p) * COORDINATE_PRECISION);
-        nearest_location.lon = static_cast<int>(q * COORDINATE_PRECISION);
-    }
-    BOOST_ASSERT(nearest_location.is_valid());
-
-    const float approximate_distance =
-        great_circle_distance(query_location, nearest_location);
-    BOOST_ASSERT(0.f <= approximate_distance);
-    return approximate_distance;
-}
-
-void lat_or_lon_to_string(const int value, std::string &output)
-{
-    char buffer[12];
-    buffer[11] = 0; // zero termination
-    output = printInt<11, 6>(buffer, value);
-}
-
-float deg_to_rad(const float degree)
-{
-    return degree * (static_cast<float>(M_PI) / 180.f);
-}
-
-float rad_to_deg(const float radian)
-{
-    return radian * (180.f * static_cast<float>(M_1_PI));
-}
-
-float bearing(const FixedPointCoordinate &first_coordinate,
-                                      const FixedPointCoordinate &second_coordinate)
-{
-    const float lon_diff =
-        second_coordinate.lon / COORDINATE_PRECISION - first_coordinate.lon / COORDINATE_PRECISION;
-    const float lon_delta = deg_to_rad(lon_diff);
-    const float lat1 = deg_to_rad(first_coordinate.lat / COORDINATE_PRECISION);
-    const float lat2 = deg_to_rad(second_coordinate.lat / COORDINATE_PRECISION);
-    const float y = std::sin(lon_delta) * std::cos(lat2);
-    const float x =
-        std::cos(lat1) * std::sin(lat2) - std::sin(lat1) * std::cos(lat2) * std::cos(lon_delta);
-    float result = rad_to_deg(std::atan2(y, x));
-    while (result < 0.f)
-    {
-        result += 360.f;
-    }
-
-    while (result >= 360.f)
-    {
-        result -= 360.f;
-    }
-    return result;
-}
-
-}

algorithms/coordinate_calculation.hpp

@@ -1,82 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef COORDINATE_CALCULATION
-#define COORDINATE_CALCULATION
-
-struct FixedPointCoordinate;
-
-#include <string>
-#include <utility>
-
-namespace coordinate_calculation
-{
-    double
-    haversine_distance(const int lat1, const int lon1, const int lat2, const int lon2);
-
-    double haversine_distance(const FixedPointCoordinate &first_coordinate,
-                                 const FixedPointCoordinate &second_coordinate);
-
-    float great_circle_distance(const FixedPointCoordinate &first_coordinate,
-                             const FixedPointCoordinate &second_coordinate);
-
-    float great_circle_distance(const int lat1, const int lon1, const int lat2, const int lon2);
-
-    void lat_or_lon_to_string(const int value, std::string &output);
-
-    float perpendicular_distance(const FixedPointCoordinate &segment_source,
-                                 const FixedPointCoordinate &segment_target,
-                                 const FixedPointCoordinate &query_location);
-
-    float perpendicular_distance(const FixedPointCoordinate &segment_source,
-                                 const FixedPointCoordinate &segment_target,
-                                 const FixedPointCoordinate &query_location,
-                                 FixedPointCoordinate &nearest_location,
-                                 float &ratio);
-
-    float perpendicular_distance_from_projected_coordinate(
-        const FixedPointCoordinate &segment_source,
-        const FixedPointCoordinate &segment_target,
-        const FixedPointCoordinate &query_location,
-        const std::pair<double, double> &projected_coordinate);
-
-    float perpendicular_distance_from_projected_coordinate(
-        const FixedPointCoordinate &segment_source,
-        const FixedPointCoordinate &segment_target,
-        const FixedPointCoordinate &query_location,
-        const std::pair<double, double> &projected_coordinate,
-        FixedPointCoordinate &nearest_location,
-        float &ratio);
-
-    float deg_to_rad(const float degree);
-    float rad_to_deg(const float radian);
-
-    float bearing(const FixedPointCoordinate &first_coordinate,
-                  const FixedPointCoordinate &second_coordinate);
-}
-
-#endif // COORDINATE_CALCULATION

algorithms/crc32_processor.hpp

@@ -1,145 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef ITERATOR_BASED_CRC32_H
-#define ITERATOR_BASED_CRC32_H
-
-#if defined(__x86_64__) && !defined(__MINGW64__)
-#include <cpuid.h>
-#endif
-
-#include <boost/crc.hpp> // for boost::crc_32_type
-
-#include <iterator>
-
-class IteratorbasedCRC32
-{
-  public:
-    bool using_hardware() const { return use_hardware_implementation; }
-
-    IteratorbasedCRC32() : crc(0) { use_hardware_implementation = detect_hardware_support(); }
-
-    template <class Iterator> unsigned operator()(Iterator iter, const Iterator end)
-    {
-        unsigned crc = 0;
-        while (iter != end)
-        {
-            using value_type = typename std::iterator_traits<Iterator>::value_type;
-            const char *data = reinterpret_cast<const char *>(&(*iter));
-
-            if (use_hardware_implementation)
-            {
-                crc = compute_in_hardware(data, sizeof(value_type));
-            }
-            else
-            {
-                crc = compute_in_software(data, sizeof(value_type));
-            }
-            ++iter;
-        }
-        return crc;
-    }
-
-  private:
-    bool detect_hardware_support() const
-    {
-        static const int sse42_bit = 0x00100000;
-        const unsigned ecx = cpuid();
-        const bool sse42_found = (ecx & sse42_bit) != 0;
-        return sse42_found;
-    }
-
-    unsigned compute_in_software(const char *str, unsigned len)
-    {
-        crc_processor.process_bytes(str, len);
-        return crc_processor.checksum();
-    }
-
-    // adapted from http://byteworm.com/2010/10/13/crc32/
-    unsigned compute_in_hardware(const char *str, unsigned len)
-    {
-#if defined(__x86_64__)
-        unsigned q = len / sizeof(unsigned);
-        unsigned r = len % sizeof(unsigned);
-        unsigned *p = (unsigned *)str;
-
-        // crc=0;
-        while (q--)
-        {
-            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
-                                 : "=S"(crc)
-                                 : "0"(crc), "c"(*p));
-            ++p;
-        }
-
-        str = reinterpret_cast<char *>(p);
-        while (r--)
-        {
-            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
-                                 : "=S"(crc)
-                                 : "0"(crc), "c"(*str));
-            ++str;
-        }
-#endif
-        return crc;
-    }
-
-    inline unsigned cpuid() const
-    {
-        unsigned eax = 0, ebx = 0, ecx = 0, edx = 0;
-        // on X64 this calls hardware cpuid(.) instr. otherwise a dummy impl.
-        __get_cpuid(1, &eax, &ebx, &ecx, &edx);
-        return ecx;
-    }
-
-#if defined(__MINGW64__) || defined(_MSC_VER) || !defined(__x86_64__)
-    inline void
-    __get_cpuid(int param, unsigned *eax, unsigned *ebx, unsigned *ecx, unsigned *edx) const
-    {
-        *ecx = 0;
-    }
-#endif
-
-    boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> crc_processor;
-    unsigned crc;
-    bool use_hardware_implementation;
-};
-
-struct RangebasedCRC32
-{
-    template <typename Iteratable> unsigned operator()(const Iteratable &iterable)
-    {
-        return crc32(std::begin(iterable), std::end(iterable));
-    }
-
-    bool using_hardware() const { return crc32.using_hardware(); }
-
-  private:
-    IteratorbasedCRC32 crc32;
-};
-
-#endif /* ITERATOR_BASED_CRC32_H */

algorithms/douglas_peucker.cpp

@@ -1,164 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#include "douglas_peucker.hpp"
-
-#include "../data_structures/segment_information.hpp"
-
-#include <boost/assert.hpp>
-#include <osrm/coordinate.hpp>
-
-#include <cmath>
-#include <algorithm>
-#include <iterator>
-
-namespace
-{
-struct CoordinatePairCalculator
-{
-    CoordinatePairCalculator() = delete;
-    CoordinatePairCalculator(const FixedPointCoordinate &coordinate_a,
-                             const FixedPointCoordinate &coordinate_b)
-    {
-        // initialize distance calculator with two fixed coordinates a, b
-        const float RAD = 0.017453292519943295769236907684886f;
-        first_lat = (coordinate_a.lat / COORDINATE_PRECISION) * RAD;
-        first_lon = (coordinate_a.lon / COORDINATE_PRECISION) * RAD;
-        second_lat = (coordinate_b.lat / COORDINATE_PRECISION) * RAD;
-        second_lon = (coordinate_b.lon / COORDINATE_PRECISION) * RAD;
-    }
-
-    int operator()(FixedPointCoordinate &other) const
-    {
-        // set third coordinate c
-        const float RAD = 0.017453292519943295769236907684886f;
-        const float earth_radius = 6372797.560856f;
-        const float float_lat1 = (other.lat / COORDINATE_PRECISION) * RAD;
-        const float float_lon1 = (other.lon / COORDINATE_PRECISION) * RAD;
-
-        // compute distance (a,c)
-        const float x_value_1 = (first_lon - float_lon1) * cos((float_lat1 + first_lat) / 2.f);
-        const float y_value_1 = first_lat - float_lat1;
-        const float dist1 = std::hypot(x_value_1, y_value_1) * earth_radius;
-
-        // compute distance (b,c)
-        const float x_value_2 = (second_lon - float_lon1) * cos((float_lat1 + second_lat) / 2.f);
-        const float y_value_2 = second_lat - float_lat1;
-        const float dist2 = std::hypot(x_value_2, y_value_2) * earth_radius;
-
-        // return the minimum
-        return static_cast<int>(std::min(dist1, dist2));
-    }
-
-    float first_lat;
-    float first_lon;
-    float second_lat;
-    float second_lon;
-};
-}
-
-void DouglasPeucker::Run(std::vector<SegmentInformation> &input_geometry, const unsigned zoom_level)
-{
-    Run(std::begin(input_geometry), std::end(input_geometry), zoom_level);
-}
-
-void DouglasPeucker::Run(RandomAccessIt begin, RandomAccessIt end, const unsigned zoom_level)
-{
-    const auto size = std::distance(begin, end);
-    if (size < 2)
-    {
-        return;
-    }
-
-    begin->necessary = true;
-    std::prev(end)->necessary = true;
-
-    {
-        BOOST_ASSERT_MSG(zoom_level < DOUGLAS_PEUCKER_THRESHOLDS.size(), "unsupported zoom level");
-        auto left_border = begin;
-        auto right_border = std::next(begin);
-        // Sweep over array and identify those ranges that need to be checked
-        do
-        {
-            // traverse list until new border element found
-            if (right_border->necessary)
-            {
-                // sanity checks
-                BOOST_ASSERT(left_border->necessary);
-                BOOST_ASSERT(right_border->necessary);
-                recursion_stack.emplace(left_border, right_border);
-                left_border = right_border;
-            }
-            ++right_border;
-        } while (right_border != end);
-    }
-
-    // mark locations as 'necessary' by divide-and-conquer
-    while (!recursion_stack.empty())
-    {
-        // pop next element
-        const GeometryRange pair = recursion_stack.top();
-        recursion_stack.pop();
-        // sanity checks
-        BOOST_ASSERT_MSG(pair.first->necessary, "left border must be necessary");
-        BOOST_ASSERT_MSG(pair.second->necessary, "right border must be necessary");
-        BOOST_ASSERT_MSG(std::distance(pair.second, end) > 0, "right border outside of geometry");
-        BOOST_ASSERT_MSG(std::distance(pair.first, pair.second) >= 0,
-                         "left border on the wrong side");
-
-        int max_int_distance = 0;
-        auto farthest_entry_it = pair.second;
-        const CoordinatePairCalculator dist_calc(pair.first->location, pair.second->location);
-
-        // sweep over range to find the maximum
-        for (auto it = std::next(pair.first); it != pair.second; ++it)
-        {
-            const int distance = dist_calc(it->location);
-            // found new feasible maximum?
-            if (distance > max_int_distance && distance > DOUGLAS_PEUCKER_THRESHOLDS[zoom_level])
-            {
-                farthest_entry_it = it;
-                max_int_distance = distance;
-            }
-        }
-
-        // check if maximum violates a zoom level dependent threshold
-        if (max_int_distance > DOUGLAS_PEUCKER_THRESHOLDS[zoom_level])
-        {
-            //  mark idx as necessary
-            farthest_entry_it->necessary = true;
-            if (1 < std::distance(pair.first, farthest_entry_it))
-            {
-                recursion_stack.emplace(pair.first, farthest_entry_it);
-            }
-            if (1 < std::distance(farthest_entry_it, pair.second))
-            {
-                recursion_stack.emplace(farthest_entry_it, pair.second);
-            }
-        }
-    }
-}

algorithms/douglas_peucker.hpp

@@ -1,81 +0,0 @@
-/*
-
-Copyright (c) 2013, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef DOUGLAS_PEUCKER_HPP_
-#define DOUGLAS_PEUCKER_HPP_
-
-#include "../data_structures/segment_information.hpp"
-
-#include <array>
-#include <stack>
-#include <utility>
-#include <vector>
-
-/* This class object computes the bitvector of indicating generalized input
- * points according to the (Ramer-)Douglas-Peucker algorithm.
- *
- * Input is vector of pairs. Each pair consists of the point information and a
- * bit indicating if the points is present in the generalization.
- * Note: points may also be pre-selected*/
-
-static const std::array<int, 19> DOUGLAS_PEUCKER_THRESHOLDS{{
-    512440, // z0
-    256720, // z1
-    122560, // z2
-    56780,  // z3
-    28800,  // z4
-    14400,  // z5
-    7200,   // z6
-    3200,   // z7
-    2400,   // z8
-    1000,   // z9
-    600,    // z10
-    120,    // z11
-    60,     // z12
-    45,     // z13
-    36,     // z14
-    20,     // z15
-    8,      // z16
-    6,      // z17
-    4       // z18
-}};
-
-class DouglasPeucker
-{
-  public:
-    using RandomAccessIt = std::vector<SegmentInformation>::iterator;
-
-    using GeometryRange = std::pair<RandomAccessIt, RandomAccessIt>;
-    // Stack to simulate the recursion
-    std::stack<GeometryRange> recursion_stack;
-
-  public:
-    void Run(RandomAccessIt begin, RandomAccessIt end, const unsigned zoom_level);
-    void Run(std::vector<SegmentInformation> &input_geometry, const unsigned zoom_level);
-};
-
-#endif /* DOUGLAS_PEUCKER_HPP_ */

algorithms/geospatial_query.hpp

@@ -1,180 +0,0 @@
-#ifndef GEOSPATIAL_QUERY_HPP
-#define GEOSPATIAL_QUERY_HPP
-
-#include "coordinate_calculation.hpp"
-#include "../typedefs.h"
-#include "../data_structures/phantom_node.hpp"
-#include "../util/bearing.hpp"
-
-#include <osrm/coordinate.hpp>
-
-#include <vector>
-#include <memory>
-#include <algorithm>
-
-// Implements complex queries on top of an RTree and builds PhantomNodes from it.
-//
-// Only holds a weak reference on the RTree!
-template <typename RTreeT> class GeospatialQuery
-{
-    using EdgeData = typename RTreeT::EdgeData;
-    using CoordinateList = typename RTreeT::CoordinateList;
-
-  public:
-    GeospatialQuery(RTreeT &rtree_, std::shared_ptr<CoordinateList> coordinates_)
-        : rtree(rtree_), coordinates(coordinates_)
-    {
-    }
-
-    // Returns nearest PhantomNodes in the given bearing range within max_distance.
-    // Does not filter by small/big component!
-    std::vector<PhantomNodeWithDistance>
-    NearestPhantomNodesInRange(const FixedPointCoordinate &input_coordinate,
-                               const float max_distance,
-                               const int bearing = 0,
-                               const int bearing_range = 180)
-    {
-        auto results =
-            rtree.Nearest(input_coordinate,
-                          [this, bearing, bearing_range, max_distance](const EdgeData &data)
-                          {
-                              return checkSegmentBearing(data, bearing, bearing_range);
-                          },
-                          [max_distance](const std::size_t, const float min_dist)
-                          {
-                              return min_dist > max_distance;
-                          });
-
-        return MakePhantomNodes(input_coordinate, results);
-    }
-
-    // Returns max_results nearest PhantomNodes in the given bearing range.
-    // Does not filter by small/big component!
-    std::vector<PhantomNodeWithDistance>
-    NearestPhantomNodes(const FixedPointCoordinate &input_coordinate,
-                        const unsigned max_results,
-                        const int bearing = 0,
-                        const int bearing_range = 180)
-    {
-        auto results = rtree.Nearest(input_coordinate,
-                                     [this, bearing, bearing_range](const EdgeData &data)
-                                     {
-                                         return checkSegmentBearing(data, bearing, bearing_range);
-                                     },
-                                     [max_results](const std::size_t num_results, const float)
-                                     {
-                                         return num_results >= max_results;
-                                     });
-
-        return MakePhantomNodes(input_coordinate, results);
-    }
-
-    // Returns the nearest phantom node. If this phantom node is not from a big component
-    // a second phantom node is return that is the nearest coordinate in a big component.
-    std::pair<PhantomNode, PhantomNode>
-    NearestPhantomNodeWithAlternativeFromBigComponent(const FixedPointCoordinate &input_coordinate,
-                                                      const int bearing = 0,
-                                                      const int bearing_range = 180)
-    {
-        bool has_small_component = false;
-        bool has_big_component = false;
-        auto results = rtree.Nearest(
-            input_coordinate,
-            [this, bearing, bearing_range, &has_big_component,
-             &has_small_component](const EdgeData &data)
-            {
-                auto use_segment =
-                    (!has_small_component || (!has_big_component && !data.component.is_tiny));
-                auto use_directions = std::make_pair(use_segment, use_segment);
-
-                if (use_segment)
-                {
-                    use_directions = checkSegmentBearing(data, bearing, bearing_range);
-                    if (use_directions.first || use_directions.second)
-                    {
-                        has_big_component = has_big_component || !data.component.is_tiny;
-                        has_small_component = has_small_component || data.component.is_tiny;
-                    }
-                }
-
-                return use_directions;
-            },
-            [&has_big_component](const std::size_t num_results, const float)
-            {
-                return num_results > 0 && has_big_component;
-            });
-
-        if (results.size() == 0)
-        {
-            return std::make_pair(PhantomNode{}, PhantomNode{});
-        }
-
-        BOOST_ASSERT(results.size() > 0);
-        return std::make_pair(MakePhantomNode(input_coordinate, results.front()).phantom_node,
-                              MakePhantomNode(input_coordinate, results.back()).phantom_node);
-    }
-
-  private:
-    std::vector<PhantomNodeWithDistance>
-    MakePhantomNodes(const FixedPointCoordinate &input_coordinate,
-                     const std::vector<EdgeData> &results) const
-    {
-        std::vector<PhantomNodeWithDistance> distance_and_phantoms(results.size());
-        std::transform(results.begin(), results.end(), distance_and_phantoms.begin(),
-                       [this, &input_coordinate](const EdgeData &data)
-                       {
-                           return MakePhantomNode(input_coordinate, data);
-                       });
-        return distance_and_phantoms;
-    }
-
-    PhantomNodeWithDistance MakePhantomNode(const FixedPointCoordinate &input_coordinate,
-                                                   const EdgeData &data) const
-    {
-        FixedPointCoordinate point_on_segment;
-        float ratio;
-        const auto current_perpendicular_distance = coordinate_calculation::perpendicular_distance(
-            coordinates->at(data.u), coordinates->at(data.v), input_coordinate, point_on_segment,
-            ratio);
-
-        auto transformed =
-            PhantomNodeWithDistance { PhantomNode{data, point_on_segment}, current_perpendicular_distance };
-
-        ratio = std::min(1.f, std::max(0.f, ratio));
-
-        if (SPECIAL_NODEID != transformed.phantom_node.forward_node_id)
-        {
-            transformed.phantom_node.forward_weight *= ratio;
-        }
-        if (SPECIAL_NODEID != transformed.phantom_node.reverse_node_id)
-        {
-            transformed.phantom_node.reverse_weight *= 1.f - ratio;
-        }
-        return transformed;
-    }
-
-    std::pair<bool, bool> checkSegmentBearing(const EdgeData &segment,
-                                              const float filter_bearing,
-                                              const float filter_bearing_range)
-    {
-        const float forward_edge_bearing =
-            coordinate_calculation::bearing(coordinates->at(segment.u), coordinates->at(segment.v));
-
-        const float backward_edge_bearing = (forward_edge_bearing + 180) > 360
-                                                ? (forward_edge_bearing - 180)
-                                                : (forward_edge_bearing + 180);
-
-        const bool forward_bearing_valid =
-            bearing::CheckInBounds(forward_edge_bearing, filter_bearing, filter_bearing_range) &&
-            segment.forward_edge_based_node_id != SPECIAL_NODEID;
-        const bool backward_bearing_valid =
-            bearing::CheckInBounds(backward_edge_bearing, filter_bearing, filter_bearing_range) &&
-            segment.reverse_edge_based_node_id != SPECIAL_NODEID;
-        return std::make_pair(forward_bearing_valid, backward_bearing_valid);
-    }
-
-    RTreeT &rtree;
-    const std::shared_ptr<CoordinateList> coordinates;
-};
-
-#endif

algorithms/graph_compressor.cpp

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

algorithms/graph_compressor.hpp

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

algorithms/object_encoder.hpp

@@ -1,89 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef OBJECT_ENCODER_HPP
-#define OBJECT_ENCODER_HPP
-
-#include <boost/assert.hpp>
-#include <boost/archive/iterators/base64_from_binary.hpp>
-#include <boost/archive/iterators/binary_from_base64.hpp>
-#include <boost/archive/iterators/transform_width.hpp>
-
-#include <algorithm>
-#include <iterator>
-#include <string>
-#include <vector>
-
-struct ObjectEncoder
-{
-    using base64_t = boost::archive::iterators::base64_from_binary<
-        boost::archive::iterators::transform_width<const char *, 6, 8>>;
-
-    using binary_t = boost::archive::iterators::transform_width<
-        boost::archive::iterators::binary_from_base64<std::string::const_iterator>,
-        8,
-        6>;
-
-    template <class ObjectT> static void EncodeToBase64(const ObjectT &object, std::string &encoded)
-    {
-        const char *char_ptr_to_object = reinterpret_cast<const char *>(&object);
-        std::vector<unsigned char> data(sizeof(object));
-        std::copy(char_ptr_to_object, char_ptr_to_object + sizeof(ObjectT), data.begin());
-
-        unsigned char number_of_padded_chars = 0; // is in {0,1,2};
-        while (data.size() % 3 != 0)
-        {
-            ++number_of_padded_chars;
-            data.push_back(0x00);
-        }
-
-        BOOST_ASSERT_MSG(0 == data.size() % 3, "base64 input data size is not a multiple of 3!");
-        encoded.resize(sizeof(ObjectT));
-        encoded.assign(base64_t(&data[0]),
-                       base64_t(&data[0] + (data.size() - number_of_padded_chars)));
-        std::replace(begin(encoded), end(encoded), '+', '-');
-        std::replace(begin(encoded), end(encoded), '/', '_');
-    }
-
-    template <class ObjectT> static void DecodeFromBase64(const std::string &input, ObjectT &object)
-    {
-        try
-        {
-            std::string encoded(input);
-            std::replace(begin(encoded), end(encoded), '-', '+');
-            std::replace(begin(encoded), end(encoded), '_', '/');
-
-            std::copy(binary_t(encoded.begin()), binary_t(encoded.begin() + encoded.length()),
-                      reinterpret_cast<char *>(&object));
-        }
-        catch (...)
-        {
-        }
-    }
-};
-
-#endif /* OBJECT_ENCODER_HPP */

algorithms/polyline_compressor.cpp

@@ -1,128 +0,0 @@
-/*
-
-Copyright (c) 2014, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#include "polyline_compressor.hpp"
-#include "../data_structures/segment_information.hpp"
-
-#include <osrm/coordinate.hpp>
-
-std::string PolylineCompressor::encode_vector(std::vector<int> &numbers) const
-{
-    std::string output;
-    const auto end = numbers.size();
-    for (std::size_t i = 0; i < end; ++i)
-    {
-        numbers[i] <<= 1;
-        if (numbers[i] < 0)
-        {
-            numbers[i] = ~(numbers[i]);
-        }
-    }
-    for (const int number : numbers)
-    {
-        output += encode_number(number);
-    }
-    return output;
-}
-
-std::string PolylineCompressor::encode_number(int number_to_encode) const
-{
-    std::string output;
-    while (number_to_encode >= 0x20)
-    {
-        const int next_value = (0x20 | (number_to_encode & 0x1f)) + 63;
-        output += static_cast<char>(next_value);
-        number_to_encode >>= 5;
-    }
-
-    number_to_encode += 63;
-    output += static_cast<char>(number_to_encode);
-    return output;
-}
-
-std::string
-PolylineCompressor::get_encoded_string(const std::vector<SegmentInformation> &polyline) const
-{
-    if (polyline.empty())
-    {
-        return {};
-    }
-
-    std::vector<int> delta_numbers;
-    delta_numbers.reserve((polyline.size() - 1) * 2);
-    FixedPointCoordinate previous_coordinate = {0, 0};
-    for (const auto &segment : polyline)
-    {
-        if (segment.necessary)
-        {
-            const int lat_diff = segment.location.lat - previous_coordinate.lat;
-            const int lon_diff = segment.location.lon - previous_coordinate.lon;
-            delta_numbers.emplace_back(lat_diff);
-            delta_numbers.emplace_back(lon_diff);
-            previous_coordinate = segment.location;
-        }
-    }
-    return encode_vector(delta_numbers);
-}
-
-std::vector<FixedPointCoordinate> PolylineCompressor::decode_string(const std::string &geometry_string) const
-{
-    std::vector<FixedPointCoordinate> new_coordinates;
-    int index = 0, len = geometry_string.size();
-    int lat = 0, lng = 0;
-  
-    while (index < len) 
-    {
-        int b, shift = 0, result = 0;
-        do 
-        {
-            b = geometry_string.at(index++) - 63;
-            result |= (b & 0x1f) << shift;
-            shift += 5;
-        } while (b >= 0x20);
-        int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
-        lat += dlat;
-
-        shift = 0;
-        result = 0;
-        do 
-        {
-            b = geometry_string.at(index++) - 63;
-            result |= (b & 0x1f) << shift;
-            shift += 5;
-        } while (b >= 0x20);
-        int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
-        lng += dlng;
-
-        FixedPointCoordinate p;
-        p.lat = COORDINATE_PRECISION * (((double) lat / 1E6));
-        p.lon = COORDINATE_PRECISION * (((double) lng / 1E6));
-        new_coordinates.push_back(p);
-    }
-
-    return new_coordinates;
-}

algorithms/polyline_compressor.hpp

@@ -1,51 +0,0 @@
-/*
-
-Copyright (c) 2013, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef POLYLINECOMPRESSOR_H_
-#define POLYLINECOMPRESSOR_H_
-
-struct SegmentInformation;
-
-#include <osrm/coordinate.hpp>
-
-#include <string>
-#include <vector>
-
-class PolylineCompressor
-{
-  private:
-    std::string encode_vector(std::vector<int> &numbers) const;
-
-    std::string encode_number(const int number_to_encode) const;
-
-  public:
-    std::string get_encoded_string(const std::vector<SegmentInformation> &polyline) const;
-    
-    std::vector<FixedPointCoordinate> decode_string(const std::string &geometry_string) const;
-};
-
-#endif /* POLYLINECOMPRESSOR_H_ */

algorithms/polyline_formatter.cpp

@@ -1,56 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#include "polyline_formatter.hpp"
-
-#include "polyline_compressor.hpp"
-#include "../data_structures/segment_information.hpp"
-
-#include <osrm/coordinate.hpp>
-
-osrm::json::String
-PolylineFormatter::printEncodedString(const std::vector<SegmentInformation> &polyline) const
-{
-    return osrm::json::String(PolylineCompressor().get_encoded_string(polyline));
-}
-
-osrm::json::Array
-PolylineFormatter::printUnencodedString(const std::vector<SegmentInformation> &polyline) const
-{
-    osrm::json::Array json_geometry_array;
-    for (const auto &segment : polyline)
-    {
-        if (segment.necessary)
-        {
-            osrm::json::Array json_coordinate;
-            json_coordinate.values.push_back(segment.location.lat / COORDINATE_PRECISION);
-            json_coordinate.values.push_back(segment.location.lon / COORDINATE_PRECISION);
-            json_geometry_array.values.push_back(json_coordinate);
-        }
-    }
-    return json_geometry_array;
-}

algorithms/polyline_formatter.hpp

@@ -1,45 +0,0 @@
-/*
-
-Copyright (c) 2014, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef POLYLINE_FORMATTER_HPP
-#define POLYLINE_FORMATTER_HPP
-
-struct SegmentInformation;
-
-#include <osrm/json_container.hpp>
-
-#include <string>
-#include <vector>
-
-struct PolylineFormatter
-{
-    osrm::json::String printEncodedString(const std::vector<SegmentInformation> &polyline) const;
-
-    osrm::json::Array printUnencodedString(const std::vector<SegmentInformation> &polyline) const;
-};
-
-#endif /* POLYLINE_FORMATTER_HPP */

algorithms/route_name_extraction.hpp

@@ -1,162 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef EXTRACT_ROUTE_NAMES_H
-#define EXTRACT_ROUTE_NAMES_H
-
-#include <boost/assert.hpp>
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-struct RouteNames
-{
-    std::string shortest_path_name_1;
-    std::string shortest_path_name_2;
-    std::string alternative_path_name_1;
-    std::string alternative_path_name_2;
-};
-
-// construct routes names
-template <class DataFacadeT, class SegmentT> struct ExtractRouteNames
-{
-  private:
-    SegmentT PickNextLongestSegment(const std::vector<SegmentT> &segment_list,
-                                    const unsigned blocked_name_id) const
-    {
-        SegmentT result_segment;
-        result_segment.length = 0;
-
-        for (const SegmentT &segment : segment_list)
-        {
-            if (segment.name_id != blocked_name_id && segment.length > result_segment.length &&
-                segment.name_id != 0)
-            {
-                result_segment = segment;
-            }
-        }
-        return result_segment;
-    }
-
-  public:
-    RouteNames operator()(std::vector<SegmentT> &shortest_path_segments,
-                          std::vector<SegmentT> &alternative_path_segments,
-                          const DataFacadeT *facade) const
-    {
-        RouteNames route_names;
-
-        SegmentT shortest_segment_1, shortest_segment_2;
-        SegmentT alternative_segment_1, alternative_segment_2;
-
-        auto length_comperator = [](const SegmentT &a, const SegmentT &b)
-        {
-            return a.length > b.length;
-        };
-        auto name_id_comperator = [](const SegmentT &a, const SegmentT &b)
-        {
-            return a.name_id < b.name_id;
-        };
-
-        if (shortest_path_segments.empty())
-        {
-            return route_names;
-        }
-
-        // pick the longest segment for the shortest path.
-        std::sort(shortest_path_segments.begin(), shortest_path_segments.end(), length_comperator);
-        shortest_segment_1 = shortest_path_segments[0];
-        if (!alternative_path_segments.empty())
-        {
-            std::sort(alternative_path_segments.begin(), alternative_path_segments.end(),
-                      length_comperator);
-
-            // also pick the longest segment for the alternative path
-            alternative_segment_1 = alternative_path_segments[0];
-        }
-
-        // compute the set difference (for shortest path) depending on names between shortest and
-        // alternative
-        std::vector<SegmentT> shortest_path_set_difference(shortest_path_segments.size());
-        std::sort(shortest_path_segments.begin(), shortest_path_segments.end(), name_id_comperator);
-        std::sort(alternative_path_segments.begin(), alternative_path_segments.end(),
-                  name_id_comperator);
-        std::set_difference(shortest_path_segments.begin(), shortest_path_segments.end(),
-                            alternative_path_segments.begin(), alternative_path_segments.end(),
-                            shortest_path_set_difference.begin(), name_id_comperator);
-
-        std::sort(shortest_path_set_difference.begin(), shortest_path_set_difference.end(),
-                  length_comperator);
-        shortest_segment_2 =
-            PickNextLongestSegment(shortest_path_set_difference, shortest_segment_1.name_id);
-
-        // compute the set difference (for alternative path) depending on names between shortest and
-        // alternative
-        // vectors are still sorted, no need to do again
-        BOOST_ASSERT(std::is_sorted(shortest_path_segments.begin(), shortest_path_segments.end(),
-                                    name_id_comperator));
-        BOOST_ASSERT(std::is_sorted(alternative_path_segments.begin(),
-                                    alternative_path_segments.end(), name_id_comperator));
-
-        std::vector<SegmentT> alternative_path_set_difference(alternative_path_segments.size());
-        std::set_difference(alternative_path_segments.begin(), alternative_path_segments.end(),
-                            shortest_path_segments.begin(), shortest_path_segments.end(),
-                            alternative_path_set_difference.begin(), name_id_comperator);
-
-        std::sort(alternative_path_set_difference.begin(), alternative_path_set_difference.end(),
-                  length_comperator);
-
-        if (!alternative_path_segments.empty())
-        {
-            alternative_segment_2 = PickNextLongestSegment(alternative_path_set_difference,
-                                                           alternative_segment_1.name_id);
-        }
-
-        // move the segments into the order in which they occur.
-        if (shortest_segment_1.position > shortest_segment_2.position)
-        {
-            std::swap(shortest_segment_1, shortest_segment_2);
-        }
-        if (alternative_segment_1.position > alternative_segment_2.position)
-        {
-            std::swap(alternative_segment_1, alternative_segment_2);
-        }
-
-        // fetching names for the selected segments
-        route_names.shortest_path_name_1 = facade->get_name_for_id(shortest_segment_1.name_id);
-        route_names.shortest_path_name_2 = facade->get_name_for_id(shortest_segment_2.name_id);
-
-        route_names.alternative_path_name_1 =
-            facade->get_name_for_id(alternative_segment_1.name_id);
-        route_names.alternative_path_name_2 =
-            facade->get_name_for_id(alternative_segment_2.name_id);
-
-        return route_names;
-    }
-};
-
-#endif // EXTRACT_ROUTE_NAMES_H

algorithms/tarjan_scc.hpp

@@ -1,204 +0,0 @@
-/*
-
-Copyright (c) 2015, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef TARJAN_SCC_HPP
-#define TARJAN_SCC_HPP
-
-#include "../typedefs.h"
-#include "../data_structures/deallocating_vector.hpp"
-#include "../data_structures/import_edge.hpp"
-#include "../data_structures/query_node.hpp"
-#include "../data_structures/percent.hpp"
-
-#include "../util/integer_range.hpp"
-#include "../util/simple_logger.hpp"
-#include "../util/std_hash.hpp"
-#include "../util/timing_util.hpp"
-
-#include <osrm/coordinate.hpp>
-#include <boost/assert.hpp>
-#include <cstdint>
-
-#include <memory>
-#include <algorithm>
-#include <climits>
-#include <stack>
-#include <vector>
-
-template <typename GraphT> class TarjanSCC
-{
-    struct TarjanStackFrame
-    {
-        explicit TarjanStackFrame(NodeID v, NodeID parent) : v(v), parent(parent) {}
-        NodeID v;
-        NodeID parent;
-    };
-
-    struct TarjanNode
-    {
-        TarjanNode() : index(SPECIAL_NODEID), low_link(SPECIAL_NODEID), on_stack(false) {}
-        unsigned index;
-        unsigned low_link;
-        bool on_stack;
-    };
-
-    std::vector<unsigned> components_index;
-    std::vector<NodeID> component_size_vector;
-    std::shared_ptr<const GraphT> m_graph;
-    std::size_t size_one_counter;
-
-  public:
-    TarjanSCC(std::shared_ptr<const GraphT> graph)
-        : components_index(graph->GetNumberOfNodes(), SPECIAL_NODEID), m_graph(graph),
-          size_one_counter(0)
-    {
-        BOOST_ASSERT(m_graph->GetNumberOfNodes() > 0);
-    }
-
-    void run()
-    {
-        TIMER_START(SCC_RUN);
-        const NodeID max_node_id = m_graph->GetNumberOfNodes();
-
-        // The following is a hack to distinguish between stuff that happens
-        // before the recursive call and stuff that happens after
-        std::stack<TarjanStackFrame> recursion_stack;
-        // true = stuff before, false = stuff after call
-        std::stack<NodeID> tarjan_stack;
-        std::vector<TarjanNode> tarjan_node_list(max_node_id);
-        unsigned component_index = 0, size_of_current_component = 0;
-        unsigned index = 0;
-        std::vector<bool> processing_node_before_recursion(max_node_id, true);
-        for (const NodeID node : osrm::irange(0u, max_node_id))
-        {
-            if (SPECIAL_NODEID == components_index[node])
-            {
-                recursion_stack.emplace(TarjanStackFrame(node, node));
-            }
-
-            while (!recursion_stack.empty())
-            {
-                TarjanStackFrame currentFrame = recursion_stack.top();
-                const NodeID u = currentFrame.parent;
-                const NodeID v = currentFrame.v;
-                recursion_stack.pop();
-
-                const bool before_recursion = processing_node_before_recursion[v];
-
-                if (before_recursion && tarjan_node_list[v].index != UINT_MAX)
-                {
-                    continue;
-                }
-
-                if (before_recursion)
-                {
-                    // Mark frame to handle tail of recursion
-                    recursion_stack.emplace(currentFrame);
-                    processing_node_before_recursion[v] = false;
-
-                    // Mark essential information for SCC
-                    tarjan_node_list[v].index = index;
-                    tarjan_node_list[v].low_link = index;
-                    tarjan_stack.push(v);
-                    tarjan_node_list[v].on_stack = true;
-                    ++index;
-
-                    for (const auto current_edge : m_graph->GetAdjacentEdgeRange(v))
-                    {
-                        const auto vprime = m_graph->GetTarget(current_edge);
-
-                        if (SPECIAL_NODEID == tarjan_node_list[vprime].index)
-                        {
-                            recursion_stack.emplace(TarjanStackFrame(vprime, v));
-                        }
-                        else
-                        {
-                            if (tarjan_node_list[vprime].on_stack &&
-                                tarjan_node_list[vprime].index < tarjan_node_list[v].low_link)
-                            {
-                                tarjan_node_list[v].low_link = tarjan_node_list[vprime].index;
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    processing_node_before_recursion[v] = true;
-                    tarjan_node_list[u].low_link =
-                        std::min(tarjan_node_list[u].low_link, tarjan_node_list[v].low_link);
-                    // after recursion, lets do cycle checking
-                    // Check if we found a cycle. This is the bottom part of the recursion
-                    if (tarjan_node_list[v].low_link == tarjan_node_list[v].index)
-                    {
-                        NodeID vprime;
-                        do
-                        {
-                            vprime = tarjan_stack.top();
-                            tarjan_stack.pop();
-                            tarjan_node_list[vprime].on_stack = false;
-                            components_index[vprime] = component_index;
-                            ++size_of_current_component;
-                        } while (v != vprime);
-
-                        component_size_vector.emplace_back(size_of_current_component);
-
-                        if (size_of_current_component > 1000)
-                        {
-                            SimpleLogger().Write() << "large component [" << component_index
-                                                   << "]=" << size_of_current_component;
-                        }
-
-                        ++component_index;
-                        size_of_current_component = 0;
-                    }
-                }
-            }
-        }
-
-        TIMER_STOP(SCC_RUN);
-        SimpleLogger().Write() << "SCC run took: " << TIMER_MSEC(SCC_RUN) / 1000. << "s";
-
-        size_one_counter = std::count_if(component_size_vector.begin(), component_size_vector.end(),
-                                         [](unsigned value)
-                                         {
-                                             return 1 == value;
-                                         });
-    }
-
-    std::size_t get_number_of_components() const { return component_size_vector.size(); }
-
-    std::size_t get_size_one_count() const { return size_one_counter; }
-
-    unsigned get_component_size(const unsigned component_id) const
-    {
-        return component_size_vector[component_id];
-    }
-
-    unsigned get_component_id(const NodeID node) const { return components_index[node]; }
-};
-
-#endif /* TARJAN_SCC_HPP */

algorithms/trip_brute_force.hpp

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

algorithms/trip_farthest_insertion.hpp

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

algorithms/trip_nearest_neighbour.hpp

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