Initial implementation

.idea

*.iml

target

.DS_Store

mock_gps_source/gps_data

kafka/data

# Licensed to the Apache Software Foundation (ASF) under one

# or more contributor license agreements.  See the NOTICE file

# distributed with this work for additional information

# regarding copyright ownership.  The ASF licenses this file

# to you under the Apache License, Version 2.0 (the

# "License"); you may not use this file except in compliance

# with the License.  You may obtain a copy of the License at

#

#   http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing,

# software distributed under the License is distributed on an

# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

# KIND, either express or implied.  See the License for the

# specific language governing permissions and limitations

# under the License.

wrapperVersion=3.3.2

distributionType=only-script

distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip

FROM bitnami/git:latest as download

WORKDIR code

RUN git clone https://github.com/geofabrik/graphhopper.git

RUN git clone https://github.com/geofabrik/OpenRailRouting.git

FROM maven:latest as assemble

RUN apt-get update

RUN apt-get -y install npm

WORKDIR code

COPY --from=download code/graphhopper graphhopper

WORKDIR graphhopper

RUN git checkout 55c3d126

RUN mvn install -DskipTests

WORKDIR ..

COPY --from=download code/OpenRailRouting OpenRailRouting

WORKDIR OpenRailRouting

RUN git checkout b6a8cb93

COPY fix__vehicle_to_profile.patch fix__vehicle_to_profile.patch

RUN git apply fix__vehicle_to_profile.patch

RUN mvn package -DskipTests

FROM openjdk:21-bullseye as run

COPY --from=assemble code/OpenRailRouting/target/railway_routing-0.0.1-SNAPSHOT.jar railway_routing.jar

COPY graph-cache.zip graph-cache.zip

RUN unzip graph-cache.zip

COPY config.yml config.yml

EXPOSE 8989

EXPOSE 8990

CMD java  \

    -Xmx2500m  \

    -Xms50m  \

    -Dlog4j.configurationFile=Log4j2.yaml  \

    -Ddw.graphhopper.graph.location=./graph-cache  \

    -jar railway_routing.jar serve config.yml

graphhopper:

  import.osm.ignored_highways: ''

  # OpenStreetMap input file

  # datareader.file: some.pbf

  ##### Vehicles #####

  ##### Routing Profiles ####

  # Routing can be done only for profiles listed below. For more information about profiles and custom profiles have a

  # look into the documentation at docs/core/profiles.md or the examples under web/src/test/java/com/graphhopper/application/resources/

  # or the CustomWeighting class for the raw details.

  #

  # In general a profile consists of the following

  # - name (required): a unique string identifier for the profile

  # - weighting (optional): by default 'custom'

  # - turn_costs (optional):

  #     vehicle_types: [train, tram, light_rail, subway] (vehicle types used for vehicle-specific turn restrictions)

  #     u_turn_costs: 60 (time-penalty for doing a u-turn in seconds)

  #

  # Depending on the above fields there are other properties that can be used, e.g.

  # - custom_model_files: when you specified "weighting: custom" you need to set one or more json files which are searched in

  #   custom_models.directory or the working directory that defines the custom_model. If you want an empty model you can

  #   set "custom_model_files: []

  #   You can also use the `custom_model` field instead and specify your custom model in the profile directly.

  #

  # To prevent long running routing queries you should usually enable either speed or hybrid mode for all the given

  # profiles (see below). Or at least limit the number of `routing.max_visited_nodes`.

  profiles:

    - name: tgv_all

      turn_costs:

        vehicle_types: [train]

        # Reversing costs 5 minutes.

        u_turn_costs: 300

      custom_model_files: [rail.json, tgv_all.json, preferred_direction.json]

    - name: non_tgv

      turn_costs:

        vehicle_types: [train]

        # Reversing costs 15 minutes.

        u_turn_costs: 900

      custom_model_files: [rail.json, non_tgv.json, preferred_direction.json]

    - name: tramtrain

      turn_costs:

        vehicle_types: [train, tram, light_rail]

        # Reversing costs 3 minutes.

        u_turn_costs: 180

      custom_model_files: [tramtrain.json, 15kv-ac_750v-dc.json, gauge_1435.json, preferred_direction.json]

    - name: all_tracks

      turn_costs:

        vehicle_types: [train, tram, light_rail, subway]

        # Reversing costs 3 minutes.

        u_turn_costs: 180

      custom_model_files: [all_tracks.json]

    - name: all_tracks_1435

      turn_costs:

        vehicle_types: [train, tram, light_rail, subway]

        # Reversing costs 3 minutes.

        u_turn_costs: 180

      custom_model_files: [all_tracks.json, gauge_1435.json]

  # instead of the inbuilt custom models (see ./src/main/resources/com/graphhopper/custom_models)

  # you can specify a folder where to find your own custom model files

  custom_models.directory: custom_models

  # Speed mode:

  # It's possible to speed up routing by doing a special graph preparation (Contraction Hierarchies, CH). This requires

  # more RAM/disk space for holding the prepared graph but also means less memory usage per request. Using the following

  # list you can define for which of the above routing profiles such preparation shall be performed. Note that to support

  # profiles with `turn_costs: true` a more elaborate preparation is required (longer preparation time and more memory

  # usage) and the routing will also be slower than with `turn_costs: false`.

  profiles_ch:

    - profile: tgv_all

    - profile: non_tgv

    - profile: tramtrain

    - profile: all_tracks

    - profile: all_tracks_1435

  # Hybrid mode:

  # Similar to speed mode, the hybrid mode (Landmarks, LM) also speeds up routing by doing calculating auxiliary data

  # in advance. Its not as fast as speed mode, but more flexible.

  #

  # Advanced usage: It is possible to use the same preparation for multiple profiles which saves memory and preparation

  # time. To do this use e.g. `preparation_profile: my_other_profile` where `my_other_profile` is the name of another

  # profile for which an LM profile exists. Important: This only will give correct routing results if the weights

  # calculated for the profile are equal or larger (for every edge) than those calculated for the profile that was used

  # for the preparation (`my_other_profile`)

  profiles_lm: []

  #### Encoded Values ####

  # Add additional information to every edge. Used for path details (#1548) and custom models (docs/core/custom-models.md)

  # Default values are: road_class,road_class_link,road_environment,max_speed,road_access

  # More are: surface,smoothness,max_width,max_height,max_weight,max_weight_except,hgv,max_axle_load,max_length,

  #           hazmat,hazmat_tunnel,hazmat_water,lanes,osm_way_id,toll,track_type,mtb_rating,hike_rating,horse_rating,

  #           country,curvature,average_slope,max_slope,car_temporal_access,bike_temporal_access,foot_temporal_access

  # For railway routing, the encoded values rail_access and rail_average_speed must be mentioned.

  graph.encoded_values: gauge,voltage,electrified,frequency,road_environment,max_speed,rail_access,rail_average_speed,railway_class,railway_service,preferred_direction

  #### Speed, hybrid and flexible mode ####

  # To make CH preparation faster for multiple profiles you can increase the default threads if you have enough RAM.

  # Change this setting only if you know what you are doing and if the default worked for you.

  # prepare.ch.threads: 1

  # To tune the performance vs. memory usage for the hybrid mode use

  # prepare.lm.landmarks: 16

  # Make landmark preparation parallel if you have enough RAM. Change this only if you know what you are doing and if

  # the default worked for you.

  # prepare.lm.threads: 1

  #### Elevation ####

  # To populate your graph with elevation data use SRTM, default is noop (no elevation). Read more about it in docs/core/elevation.md

  # graph.elevation.provider: srtm

  # default location for cache is /tmp/srtm

  # graph.elevation.cache_dir: ./srtmprovider/

  # If you have a slow disk or plenty of RAM change the default MMAP to:

  # graph.elevation.dataaccess: RAM_STORE

  # To enable bilinear interpolation when sampling elevation at points (default uses nearest neighbor):

  # graph.elevation.interpolate: bilinear

  # Reduce ascend/descend per edge without changing the maximum slope:

  # graph.elevation.edge_smoothing: ramer

  # removes elevation fluctuations up to max_elevation (in meter) and replaces the elevation with a value based on the average slope

  # graph.elevation.edge_smoothing.ramer.max_elevation: 5

  # Using an averaging approach for smoothing will reveal values not affected by outliers and realistic slopes and total altitude values (up and down)

  # graph.elevation.edge_smoothing: moving_average

  # window size in meter along a way used for averaging a node's elevation

  # graph.elevation.edge_smoothing.moving_average.window_size: 150

  # To increase elevation profile resolution, use the following two parameters to tune the extra resolution you need

  # against the additional storage space used for edge geometries. You should enable bilinear interpolation when using

  # these features (see #1953 for details).

  # - first, set the distance (in meters) at which elevation samples should be taken on long edges

  # graph.elevation.long_edge_sampling_distance: 60

  # - second, set the elevation tolerance (in meters) to use when simplifying polylines since the default ignores

  #   elevation and will remove the extra points that long edge sampling added

  # graph.elevation.way_point_max_distance: 10

  #### Country-dependent defaults for max speeds ####

  # This features sets a maximum speed in 'max_speed' encoded value if no maxspeed tag was found. It is country-dependent

  # and based on several rules. See https://github.com/westnordost/osm-legal-default-speeds

  # To use it uncomment the following, then enable urban density below and add 'country' to graph.encoded_values

  # max_speed_calculator.enabled: true

  #### Urban density (built-up areas) ####

  # This feature allows classifying roads into 'rural', 'residential' and 'city' areas (encoded value 'urban_density')

  # Use 1 or more threads to enable the feature

  # graph.urban_density.threads: 8

  # Use higher/lower sensitivities if too little/many roads fall into the according categories.

  # Using smaller radii will speed up the classification, but only change these values if you know what you are doing.

  # If you do not need the (rather slow) city classification set city_radius to zero.

  # graph.urban_density.residential_radius: 400

  # graph.urban_density.residential_sensitivity: 6000

  # graph.urban_density.city_radius: 1500

  # graph.urban_density.city_sensitivity: 1000

  #### Subnetworks ####

  # In many cases the road network consists of independent components without any routes going in between. In

  # the most simple case you can imagine an island without a bridge or ferry connection. The following parameter

  # allows setting a minimum size (number of edges) for such detached components. This can be used to reduce the number

  # of cases where a connection between locations might not be found.

  prepare.min_network_size: 200

  prepare.subnetworks.threads: 1

  #### Routing ####

  # You can define the maximum visited nodes when routing. This may result in not found connections if there is no

  # connection between two points within the given visited nodes. The default is Integer.MAX_VALUE. Useful for flexibility mode

  # routing.max_visited_nodes: 1000000

  # The maximum time in milliseconds after which a routing request will be aborted. This has some routing algorithm

  # specific caveats, but generally it should allow the prevention of long-running requests. The default is Long.MAX_VALUE

  # routing.timeout_ms: 300000

  # Control how many active landmarks are picked per default, this can improve query performance

  # routing.lm.active_landmarks: 4

  # You can limit the max distance between two consecutive waypoints of flexible routing requests to be less or equal

  # the given distance in meter. Default is set to 1000km.

  routing.non_ch.max_waypoint_distance: 1000000

  #### Storage ####

  # Excludes certain types of highways during the OSM import to speed up the process and reduce the size of the graph.

  # A typical application is excluding 'footway','cycleway','path' and maybe 'pedestrian' and 'track' highways for

  # motorized vehicles. This leads to a smaller and less dense graph, because there are fewer ways (obviously),

  # but also because there are fewer crossings between highways (=junctions).

  # Another typical example is excluding 'motorway', 'trunk' and maybe 'primary' highways for bicycle or pedestrian routing.

  # import.osm.ignored_highways: footway,cycleway,path,pedestrian,steps # typically useful for motorized-only routing

  # import.osm.ignored_highways: motorway,trunk # typically useful for non-motorized routing

  # configure the memory access, use RAM_STORE for well equipped servers (default and recommended)

  graph.dataaccess.default_type: RAM_STORE

  # will write way names in the preferred language (language code as defined in ISO 639-1 or ISO 639-2):

  # datareader.preferred_language: en

  #### Custom Areas ####

  # GraphHopper reads GeoJSON polygon files including their properties from this directory and makes them available

  # to all tag parsers and custom models. All GeoJSON Features require to have the "id" property.

  # Country borders are included automatically (see countries.geojson).

  # custom_areas.directory: path/to/custom_areas

  #### Country Rules ####

  # GraphHopper applies country-specific routing rules during import (not enabled by default).

  # You need to redo the import for changes to take effect.

  # country_rules.enabled: true

# Dropwizard server configuration

server:

  application_connectors:

    - type: http

      port: 8989

      # for security reasons bind to localhost

      bind_host: 0.0.0.0

      # increase GET request limit - not necessary if /maps UI is not used or used without custom models

      max_request_header_size: 50k

  request_log:

    appenders: []

  admin_connectors:

    - type: http

      port: 8990

      bind_host: 0.0.0.0

# See https://www.dropwizard.io/en/latest/manual/core.html#logging

logging:

  level: INFO

  appenders:

    - type: console

      time_zone: UTC

      log_format: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"

  loggers:

    "com.graphhopper.osm_warnings":

      level: DEBUG

      additive: false

      appenders:

        - type: console

          logFormat: '[%level] %msg%n'

services:

  rail-routing:

    build:

      context: .

    ports:

      - "8989:8989"

      - "8990:8990"