From 8842528174a51d7b4426c1000e6c40aea3b5b3db Mon Sep 17 00:00:00 2001 From: Karl Schrab Date: Fri, 29 Nov 2024 17:20:16 +0100 Subject: [PATCH] feat(routing): use graphhopper to provide GTFS based public transport routing --- bundle/src/assembly/mosaic-bundle.xml | 7 + .../ambassador/ApplicationAmbassador.java | 3 +- .../CentralNavigationComponent.java | 35 +- .../config/CApplicationAmbassador.java | 24 +- .../CentralNavigationComponentTest.java | 9 +- .../CentralNavigationComponentTestRule.java | 2 +- lib/mosaic-routing/pom.xml | 8 + .../eclipse/mosaic/lib/routing/Routing.java | 4 +- .../config/CPublicTransportRouting.java | 26 + .../{CRouting.java => CVehicleRouting.java} | 2 +- .../lib/routing/database/DatabaseRouting.java | 4 +- .../lib/routing/norouting/NoRouting.java | 4 +- .../mosaic/lib/routing/pt/MultiModalLeg.java | 86 + .../lib/routing/pt/MultiModalRoute.java | 53 + .../eclipse/mosaic/lib/routing/pt/PtLeg.java | 37 + .../mosaic/lib/routing/pt/PtRouting.java | 183 + .../lib/routing/pt/PtRoutingParameters.java | 35 + .../lib/routing/pt/PtRoutingRequest.java | 54 + .../lib/routing/pt/PtRoutingResponse.java | 29 + .../lib/routing/pt/PtTimeConversion.java | 70 + .../mosaic/lib/routing/pt/WalkLeg.java | 34 + .../routing/database/DatabaseRoutingTest.java | 6 +- .../mosaic/lib/routing/pt/PtRoutingTest.java | 110 + .../src/test/resources/pt/pt-gtfs.zip | Bin 0 -> 1770 bytes .../src/test/resources/pt/pt.osm | 16852 ++++++++++++++++ pom.xml | 38 +- 26 files changed, 17684 insertions(+), 31 deletions(-) create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CPublicTransportRouting.java rename lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/{CRouting.java => CVehicleRouting.java} (93%) create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/MultiModalLeg.java create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/MultiModalRoute.java create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtLeg.java create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRouting.java create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingParameters.java create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingRequest.java create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingResponse.java create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtTimeConversion.java create mode 100644 lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/WalkLeg.java create mode 100644 lib/mosaic-routing/src/test/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingTest.java create mode 100644 lib/mosaic-routing/src/test/resources/pt/pt-gtfs.zip create mode 100644 lib/mosaic-routing/src/test/resources/pt/pt.osm diff --git a/bundle/src/assembly/mosaic-bundle.xml b/bundle/src/assembly/mosaic-bundle.xml index 0fb75cf06..c0d73ba4c 100644 --- a/bundle/src/assembly/mosaic-bundle.xml +++ b/bundle/src/assembly/mosaic-bundle.xml @@ -151,6 +151,13 @@ org.locationtech.jts:jts-core + + com.graphhopper:graphhopper-reader-gtfs + io.mobilitydata.transit:gtfs-realtime-bindings + net.sourceforge.javacsv:javacsv + org.mapdb:mapdb + + com.github.mwiede:jsch com.google.protobuf:protobuf-java org.xerial:sqlite-jdbc diff --git a/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/ambassador/ApplicationAmbassador.java b/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/ambassador/ApplicationAmbassador.java index 0dd058512..80d3ae747 100644 --- a/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/ambassador/ApplicationAmbassador.java +++ b/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/ambassador/ApplicationAmbassador.java @@ -141,7 +141,8 @@ public ApplicationAmbassador(AmbassadorParameter ambassadorParameter) { // set the CNC (central navigation component) CentralNavigationComponent cnc = new CentralNavigationComponent( ambassadorParameter, - ambassadorConfig.navigationConfiguration + ambassadorConfig.navigationConfiguration, + ambassadorConfig.publicTransportConfiguration ); SimulationKernel.SimulationKernel.setCentralNavigationComponent(cnc); } diff --git a/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponent.java b/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponent.java index 63834b9db..40dc6eeb5 100644 --- a/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponent.java +++ b/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponent.java @@ -38,8 +38,12 @@ import org.eclipse.mosaic.lib.routing.RoutingPosition; import org.eclipse.mosaic.lib.routing.RoutingRequest; import org.eclipse.mosaic.lib.routing.RoutingResponse; +import org.eclipse.mosaic.lib.routing.config.CPublicTransportRouting; import org.eclipse.mosaic.lib.routing.database.DatabaseRouting; import org.eclipse.mosaic.lib.routing.norouting.NoRouting; +import org.eclipse.mosaic.lib.routing.pt.PtRouting; +import org.eclipse.mosaic.lib.routing.pt.PtRoutingRequest; +import org.eclipse.mosaic.lib.routing.pt.PtRoutingResponse; import org.eclipse.mosaic.rti.api.IllegalValueException; import org.eclipse.mosaic.rti.api.Interaction; import org.eclipse.mosaic.rti.api.InternalFederateException; @@ -83,11 +87,22 @@ public class CentralNavigationComponent { */ private Routing routing; + + /** + * Public Transport routing + */ + private PtRouting ptRouting; + /** * The configuration for routingAPI. */ private CApplicationAmbassador.CRoutingByType configuration; + /** + * The configuration for public transport routing. + */ + private CPublicTransportRouting ptConfiguration; + /** * Constructor for the CentralNavigationComponent. * Sets the logger and the configuration for navigation. @@ -99,10 +114,12 @@ public class CentralNavigationComponent { */ public CentralNavigationComponent( final AmbassadorParameter ambassadorParameter, - CApplicationAmbassador.CRoutingByType navigationConfiguration + CApplicationAmbassador.CRoutingByType navigationConfiguration, + CPublicTransportRouting publicTransportConfiguration ) { this.applicationAmbassadorParameter = ambassadorParameter; this.configuration = navigationConfiguration; + this.ptConfiguration = publicTransportConfiguration; } /** @@ -124,11 +141,14 @@ public void initialize(RtiAmbassador rtiAmbassador) throws InternalFederateExcep routing = createFromType(this.configuration != null ? this.configuration.type : null); routing.initialize(configuration, applicationAmbassadorParameter.configuration.getParentFile()); + ptRouting = new PtRouting(); + ptRouting.initialize(ptConfiguration, applicationAmbassadorParameter.configuration.getParentFile()); + this.log.info("CNC - Navigation-System initialized"); try { final Map routeMap = routing.getRoutesFromDatabaseForMessage(); - for (var routeEntry: routeMap.entrySet()) { + for (var routeEntry : routeMap.entrySet()) { SimulationKernel.SimulationKernel.registerRoute(routeEntry.getKey(), routeEntry.getValue()); } @@ -289,6 +309,17 @@ public GeoPoint getSourcePositionOfRoute(String routeId) { } } + /** + * Find a public transport route from a provided position to a provided target position at a specific request time. + * + * @param routingRequest A {@link PtRoutingRequest} that contains + * the origin, the end, the request time, and additional + * routing parameters to calculate the public transport route. + */ + PtRoutingResponse findPtRoute(PtRoutingRequest routingRequest) { + return ptRouting.findPtRoute(routingRequest); + } + /** * Provides the current routing API implementation. * diff --git a/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/config/CApplicationAmbassador.java b/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/config/CApplicationAmbassador.java index c03116e4c..223b45795 100644 --- a/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/config/CApplicationAmbassador.java +++ b/fed/mosaic-application/src/main/java/org/eclipse/mosaic/fed/application/config/CApplicationAmbassador.java @@ -15,7 +15,8 @@ package org.eclipse.mosaic.fed.application.config; -import org.eclipse.mosaic.lib.routing.config.CRouting; +import org.eclipse.mosaic.lib.routing.config.CPublicTransportRouting; +import org.eclipse.mosaic.lib.routing.config.CVehicleRouting; import org.eclipse.mosaic.lib.util.gson.TimeFieldAdapter; import org.eclipse.mosaic.lib.util.scheduling.MultiThreadedEventScheduler; import org.eclipse.mosaic.rti.TIME; @@ -53,6 +54,12 @@ public class CApplicationAmbassador implements Serializable { */ public int eventSchedulerThreads = 1; + /** + * Configuration options for route calculation via public transport. + * Requires paths to OSM and GTFS files. + */ + public CPublicTransportRouting publicTransportConfiguration = new CPublicTransportRouting(); + /** * Class containing the information for the configuration of the * Routing/Navigation (CentralNavigationComponent). @@ -60,11 +67,17 @@ public class CApplicationAmbassador implements Serializable { public CRoutingByType navigationConfiguration = null; /** - * Extends the {@link CRouting} configuration with a type parameter + * Configuration for the perception backend used in the ApplicationSimulator + * to determine surrounding vehicles. + */ + public CPerception perceptionConfiguration = new CPerception(); + + /** + * Extends the {@link CVehicleRouting} configuration with a type parameter * allowing to define the actual {@link org.eclipse.mosaic.lib.routing.Routing} * implementation to use. */ - public static class CRoutingByType extends CRouting implements Serializable { + public static class CRoutingByType extends CVehicleRouting implements Serializable { /** * Defines the {@link org.eclipse.mosaic.lib.routing.Routing} implementation @@ -74,9 +87,4 @@ public static class CRoutingByType extends CRouting implements Serializable { public String type = null; } - /** - * Configuration for the perception backend used in the ApplicationSimulator - * to determine surrounding vehicles. - */ - public CPerception perceptionConfiguration = new CPerception(); } diff --git a/fed/mosaic-application/src/test/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponentTest.java b/fed/mosaic-application/src/test/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponentTest.java index 77e905f13..60c4e6dd2 100644 --- a/fed/mosaic-application/src/test/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponentTest.java +++ b/fed/mosaic-application/src/test/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponentTest.java @@ -48,7 +48,8 @@ import org.eclipse.mosaic.lib.routing.RoutingParameters; import org.eclipse.mosaic.lib.routing.RoutingPosition; import org.eclipse.mosaic.lib.routing.RoutingRequest; -import org.eclipse.mosaic.lib.routing.config.CRouting; +import org.eclipse.mosaic.lib.routing.config.CPublicTransportRouting; +import org.eclipse.mosaic.lib.routing.config.CVehicleRouting; import org.eclipse.mosaic.lib.routing.norouting.NoRouting; import org.eclipse.mosaic.rti.TIME; import org.eclipse.mosaic.rti.api.IllegalValueException; @@ -125,7 +126,7 @@ public void initialize_vehicleRoutesInitializationSent() throws InternalFederate cnc.initialize(rtiAmbassadorMock); //ASSERT - verify(routingMock).initialize(isNull(CRouting.class), isA(File.class)); + verify(routingMock).initialize(isNull(CVehicleRouting.class), isA(File.class)); verify(rtiAmbassadorMock).triggerInteraction(isA(VehicleRoutesInitialization.class)); } @@ -246,7 +247,7 @@ public void initializeNoRouting() throws InternalFederateException, IOException routingConfig.type = "no-routing"; CentralNavigationComponent centralNavigationComponent - = new CentralNavigationComponent(ambassadorParameter,routingConfig ); + = new CentralNavigationComponent(ambassadorParameter, routingConfig, new CPublicTransportRouting()); centralNavigationComponent.initialize(rtiAmbassadorMock); assertNotNull(centralNavigationComponent.getRouting()); @@ -264,7 +265,7 @@ public void initializeMyTestRouting() throws InternalFederateException, IOExcept routingConfig.type = MyTestRouting.class.getCanonicalName(); CentralNavigationComponent centralNavigationComponent - = new CentralNavigationComponent(ambassadorParameter,routingConfig ); + = new CentralNavigationComponent(ambassadorParameter, routingConfig, new CPublicTransportRouting()); centralNavigationComponent.initialize(rtiAmbassadorMock); assertNotNull(centralNavigationComponent.getRouting()); diff --git a/fed/mosaic-application/src/test/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponentTestRule.java b/fed/mosaic-application/src/test/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponentTestRule.java index fb6d220e1..5aa5232f3 100644 --- a/fed/mosaic-application/src/test/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponentTestRule.java +++ b/fed/mosaic-application/src/test/java/org/eclipse/mosaic/fed/application/ambassador/simulation/navigation/CentralNavigationComponentTestRule.java @@ -63,7 +63,7 @@ protected void before() throws Throwable { CApplicationAmbassador applicationConfig = new CApplicationAmbassador(); AmbassadorParameter ambassadorParameters = new AmbassadorParameter("test", configCopy.getParentFile()); - centralNavigationComponent = new CentralNavigationComponent(ambassadorParameters, applicationConfig.navigationConfiguration) { + centralNavigationComponent = new CentralNavigationComponent(ambassadorParameters, applicationConfig.navigationConfiguration, applicationConfig.publicTransportConfiguration) { @Override Routing createFromType(String type) throws InternalFederateException { return routingMock; diff --git a/lib/mosaic-routing/pom.xml b/lib/mosaic-routing/pom.xml index 40b011110..ceaa0ff01 100644 --- a/lib/mosaic-routing/pom.xml +++ b/lib/mosaic-routing/pom.xml @@ -34,6 +34,14 @@ com.graphhopper graphhopper-core + + com.graphhopper + graphhopper-reader-gtfs + + + io.mobilitydata.transit + gtfs-realtime-bindings + com.google.guava guava diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/Routing.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/Routing.java index d3be8cef5..274583935 100644 --- a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/Routing.java +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/Routing.java @@ -21,7 +21,7 @@ import org.eclipse.mosaic.lib.objects.road.INode; import org.eclipse.mosaic.lib.objects.road.IRoadPosition; import org.eclipse.mosaic.lib.objects.vehicle.VehicleRoute; -import org.eclipse.mosaic.lib.routing.config.CRouting; +import org.eclipse.mosaic.lib.routing.config.CVehicleRouting; import org.eclipse.mosaic.rti.api.InternalFederateException; import java.io.File; @@ -35,7 +35,7 @@ public interface Routing { /** * Initializes the connection to the belonging database. */ - void initialize(CRouting routingConfiguration, File configurationLocation) throws InternalFederateException; + void initialize(CVehicleRouting routingConfiguration, File configurationLocation) throws InternalFederateException; /** * Find a route from your actual position to the target position. diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CPublicTransportRouting.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CPublicTransportRouting.java new file mode 100644 index 000000000..d1316d205 --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CPublicTransportRouting.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.config; + +public class CPublicTransportRouting { + + public boolean enabled = false; + + public String osmFile = "map.osm"; + public String gtfsFile = "gtfs.zip"; + public String scheduleDateTime = "2024-12-03T10:15:30"; + public String timeZone = "ECT"; +} diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CRouting.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CVehicleRouting.java similarity index 93% rename from lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CRouting.java rename to lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CVehicleRouting.java index 5e94530f5..77ae27ebc 100644 --- a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CRouting.java +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/config/CVehicleRouting.java @@ -20,7 +20,7 @@ /** * Base Class for the navigation configuration. */ -public class CRouting implements Serializable { +public class CVehicleRouting implements Serializable { /** * The source for the route calculation, e.g. the path to the database containing the road network. diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/database/DatabaseRouting.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/database/DatabaseRouting.java index 1186b05b2..6a37d0970 100644 --- a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/database/DatabaseRouting.java +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/database/DatabaseRouting.java @@ -36,7 +36,7 @@ import org.eclipse.mosaic.lib.routing.Routing; import org.eclipse.mosaic.lib.routing.RoutingRequest; import org.eclipse.mosaic.lib.routing.RoutingResponse; -import org.eclipse.mosaic.lib.routing.config.CRouting; +import org.eclipse.mosaic.lib.routing.config.CVehicleRouting; import org.eclipse.mosaic.lib.routing.graphhopper.GraphHopperRouting; import org.eclipse.mosaic.rti.api.InternalFederateException; @@ -65,7 +65,7 @@ public class DatabaseRouting implements Routing { private GraphHopperRouting routing; @Override - public void initialize(final CRouting configuration, final File baseDirectory) throws InternalFederateException { + public void initialize(final CVehicleRouting configuration, final File baseDirectory) throws InternalFederateException { File dbFile; // try to find the database file diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/norouting/NoRouting.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/norouting/NoRouting.java index 6922e1ef5..58f0fd096 100644 --- a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/norouting/NoRouting.java +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/norouting/NoRouting.java @@ -27,7 +27,7 @@ import org.eclipse.mosaic.lib.routing.Routing; import org.eclipse.mosaic.lib.routing.RoutingRequest; import org.eclipse.mosaic.lib.routing.RoutingResponse; -import org.eclipse.mosaic.lib.routing.config.CRouting; +import org.eclipse.mosaic.lib.routing.config.CVehicleRouting; import org.eclipse.mosaic.rti.api.InternalFederateException; import com.google.common.collect.Lists; @@ -44,7 +44,7 @@ public class NoRouting implements Routing { @Override - public void initialize(CRouting configuration, File configurationLocation) throws InternalFederateException { + public void initialize(CVehicleRouting configuration, File configurationLocation) throws InternalFederateException { // nop } diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/MultiModalLeg.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/MultiModalLeg.java new file mode 100644 index 000000000..e62fbaec0 --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/MultiModalLeg.java @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +import org.eclipse.mosaic.lib.objects.vehicle.VehicleDeparture; + +public class MultiModalLeg { + + public enum Type { + WALKING, VEHICLE_SHARED, VEHICLE_PRIVATE, PUBLIC_TRANSPORT + } + + private Type legType; + + //For legs where a vehicle needs to be spawned + private VehicleDeparture vehicleLeg = null; + + //For PTlegs + private PtLeg publicTransportationLeg = null; + + private WalkLeg walkLeg = null; + + //For legs where a vehicle already exists + private String carID = null; + + public long departureTime; + public long arrivalTime; + + public MultiModalLeg(VehicleDeparture vehicleLeg, long departureTime, long arrivalTime) { + this.legType = Type.VEHICLE_PRIVATE; + this.vehicleLeg = vehicleLeg; + + this.departureTime = departureTime; + this.arrivalTime = arrivalTime; + } + + public MultiModalLeg(PtLeg ptRoute, long departureTime, long arrivalTime) { + this.legType = Type.PUBLIC_TRANSPORT; + this.publicTransportationLeg = ptRoute; + + this.departureTime = departureTime; + this.arrivalTime = arrivalTime; + } + + public MultiModalLeg(WalkLeg walkLeg, long departureTime, long arrivalTime) { + this.legType = Type.WALKING; + this.walkLeg = walkLeg; + + this.departureTime = departureTime; + this.arrivalTime = arrivalTime; + } + + public MultiModalLeg(String carID, long departureTime, long arrivalTime) { + this.legType = Type.VEHICLE_PRIVATE; + this.carID = carID; + + this.departureTime = departureTime; + this.arrivalTime = arrivalTime; + } + + public Object getLeg() { + return switch (legType) { + case VEHICLE_PRIVATE -> vehicleLeg; + case VEHICLE_SHARED -> carID; + case PUBLIC_TRANSPORT -> publicTransportationLeg; + case WALKING -> walkLeg; + }; + } + + public Type getLegType() { + return legType; + } +} diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/MultiModalRoute.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/MultiModalRoute.java new file mode 100644 index 000000000..2dce0b4ab --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/MultiModalRoute.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +import java.util.ArrayList; +import java.util.List; + +public class MultiModalRoute { + + private final List legs = new ArrayList<>(); + + public MultiModalRoute(List legs) { + this.legs.addAll(legs); + } + + public List getLegs() { + return this.legs; + } + + /** + * can be used to check if the route exists and is valid, + * if allowTeleportation is set to true it ignores arrival/ departure times + * + * @return whether or not a valid route exists and is valid + */ + public boolean checkValidity() { + if (!legs.isEmpty()) { + for (int i = 0; i < legs.size() - 1; i++) { + if (legs.get(i).arrivalTime > legs.get(i + 1).departureTime) { + return false; + } + } + } else { + return false; + } + return true; + } + + +} diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtLeg.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtLeg.java new file mode 100644 index 000000000..6351083ec --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtLeg.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +import org.eclipse.mosaic.lib.geo.GeoPoint; + +import java.util.ArrayList; +import java.util.List; + +public class PtLeg { + + public record PtStop(GeoPoint location, Long departureTime, Long arrivalTime) {} + + private final List legs = new ArrayList<>(); + + public PtLeg(List legs) { + this.legs.addAll(legs); + } + + public List getLegs() { + return legs; + } + +} diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRouting.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRouting.java new file mode 100644 index 000000000..4dad4bc25 --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRouting.java @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +import org.eclipse.mosaic.lib.geo.GeoPoint; +import org.eclipse.mosaic.lib.routing.config.CPublicTransportRouting; + +import com.google.common.collect.Iterables; +import com.graphhopper.GHResponse; +import com.graphhopper.GraphHopperConfig; +import com.graphhopper.ResponsePath; +import com.graphhopper.Trip; +import com.graphhopper.config.Profile; +import com.graphhopper.gtfs.GraphHopperGtfs; +import com.graphhopper.gtfs.PtRouter; +import com.graphhopper.gtfs.PtRouterImpl; +import com.graphhopper.gtfs.Request; +import com.graphhopper.util.StopWatch; +import com.graphhopper.util.TranslationMap; +import org.apache.commons.lang3.Validate; +import org.locationtech.jts.geom.Coordinate; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.File; +import java.nio.file.Path; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.time.temporal.ChronoUnit; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Date; +import java.util.List; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class PtRouting { + + private static final Logger LOG = LoggerFactory.getLogger(PtRouting.class); + + private final ExecutorService routingExecution = Executors.newSingleThreadExecutor(); + + private PtRouter ptRouter; + private GraphHopperGtfs graphHopperGtfs; + + private LocalDateTime scheduleDateTime; + private ZoneId timeZone; + + public void initialize(CPublicTransportRouting routingConfiguration, File configurationLocation) { + if (!routingConfiguration.enabled) { + return; + } + + Path baseDirectory = configurationLocation.toPath(); + + GraphHopperConfig ghConfig = new GraphHopperConfig() + .putObject("import.osm.ignored_highways", "motorway,trunk,primary") + .putObject("graph.location", baseDirectory.resolve("ptgraph").toAbsolutePath().toString()) + .putObject("datareader.file", baseDirectory.resolve(routingConfiguration.osmFile).toAbsolutePath().toString()) + .putObject("gtfs.file", baseDirectory.resolve(routingConfiguration.gtfsFile).toAbsolutePath().toString()) + .setProfiles(Collections.singletonList(new Profile("foot").setVehicle("foot"))); + + scheduleDateTime = LocalDateTime.parse(routingConfiguration.scheduleDateTime, DateTimeFormatter.ISO_DATE_TIME); + timeZone = ZoneId.of(ZoneId.SHORT_IDS.get(routingConfiguration.timeZone)); + + final StopWatch sw = new StopWatch(); + sw.start(); + graphHopperGtfs = new GraphHopperGtfs(ghConfig); + graphHopperGtfs.init(ghConfig); + graphHopperGtfs.importOrLoad(); + sw.stop(); + LOG.debug("Took {} ms to load public transport router.", sw.getMillis()); + + LOG.info("setting ptRouter"); + ptRouter = new PtRouterImpl.Factory(ghConfig, + new TranslationMap().doImport(), + graphHopperGtfs.getBaseGraph(), + graphHopperGtfs.getEncodingManager(), + graphHopperGtfs.getLocationIndex(), + graphHopperGtfs.getGtfsStorage() + ).createWithoutRealtimeFeed(); + } + + + + public PtRoutingResponse findPtRoute(PtRoutingRequest request) { + if (ptRouter == null) { + throw new IllegalStateException("PT Routing is not available. Must be enabled in application_config.json."); + } + Validate.isTrue(request.getRoutingParameters().getWalkingSpeedMps() > 0, "Walking speed must be greater than 0."); + + Instant departureTime = toScheduleTime(request.getRequestTime()); + + final Request ghRequest = new Request( + request.getStartingGeoPoint().getLatitude(), + request.getStartingGeoPoint().getLongitude(), + request.getTargetGeoPoint().getLatitude(), + request.getTargetGeoPoint().getLongitude() + ); +// ghRequest.setBlockedRouteTypes(request.getRoutingParameters().excludedPtModes);//FIXME generalize this + ghRequest.setEarliestDepartureTime(departureTime); + ghRequest.setWalkSpeedKmH(request.getRoutingParameters().getWalkingSpeedMps() * 3.6); + + final Future responseFuture = routingExecution.submit(() -> ptRouter.route(ghRequest)); + final GHResponse route; + try { + final StopWatch sw = new StopWatch(); + sw.start(); + route = responseFuture.get(30, TimeUnit.SECONDS); + sw.stop(); + LOG.debug("Took {} ms to calculate public transport route.", sw.getMillis()); + } catch (TimeoutException e) { + responseFuture.cancel(true); + throw new RuntimeException("Could not finish route calculation. Exceeded timeout."); + } catch (InterruptedException | ExecutionException e) { + throw new RuntimeException("Could not finish route calculation. Exceeded timeout.", e); + } + + final List legs = convertToMultiModalLegs(route.getBest()); + + return new PtRoutingResponse(new MultiModalRoute(legs)); + } + + private List convertToMultiModalLegs(ResponsePath ghBestRoute) { + List legs = new ArrayList<>(); + for (Trip.Leg leg : ghBestRoute.getLegs()) { + if (leg instanceof Trip.PtLeg ptLeg) { + List newStops = new ArrayList<>(); + for (Trip.Stop stop : ptLeg.stops) { + newStops.add(new PtLeg.PtStop(GeoPoint.lonLat(stop.geometry.getX(), stop.geometry.getY()), fromScheduleTime(stop.departureTime), fromScheduleTime(stop.arrivalTime))); + } + legs.add(new MultiModalLeg( + new PtLeg(newStops), newStops.get(0).departureTime(), Iterables.getLast(newStops).arrivalTime()) + ); + } else if (leg instanceof Trip.WalkLeg walkLeg) { + List waypoints = new ArrayList<>(); + for (Coordinate coordinate : walkLeg.geometry.getCoordinates()) { + waypoints.add(GeoPoint.lonLat(coordinate.x, coordinate.y)); + } + legs.add(new MultiModalLeg(new WalkLeg(waypoints), fromScheduleTime(leg.getDepartureTime()), fromScheduleTime(leg.getArrivalTime()))); + } + } + return legs; + } + + private Instant toScheduleTime(long simTime) { + return scheduleDateTime.plusNanos(simTime).atZone(timeZone).toInstant(); + } + + private Long fromScheduleTime(Date date) { + if (date == null) { + return null; + } + return fromScheduleTime(date.toInstant()); + } + + private long fromScheduleTime(Instant instant) { + return scheduleDateTime.until(LocalDateTime.ofInstant(instant, timeZone), ChronoUnit.NANOS); + } + + public void close() { + graphHopperGtfs.close(); + } +} diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingParameters.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingParameters.java new file mode 100644 index 000000000..4f92c1790 --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingParameters.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +public class PtRoutingParameters { + + private double walkingSpeedMps = 5 / 3.6; + + public PtRoutingParameters walkingSpeedKmh(double kmh) { + walkingSpeedMps = kmh / 3.6; + return this; + } + + public PtRoutingParameters walkingSpeedMps(double meterPerSecond) { + walkingSpeedMps = meterPerSecond; + return this; + } + + public double getWalkingSpeedMps() { + return walkingSpeedMps; + } +} diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingRequest.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingRequest.java new file mode 100644 index 000000000..0682be96b --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingRequest.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +import org.eclipse.mosaic.lib.geo.GeoPoint; + +public class PtRoutingRequest { + + private final long requestTime; + private final GeoPoint startingGeoPoint; + private final GeoPoint targetGeoPoint; + + private final PtRoutingParameters routingParameters; + + public PtRoutingRequest(long requestTime, GeoPoint from, GeoPoint to) { + this(requestTime, from, to, new PtRoutingParameters()); + } + + public PtRoutingRequest(long requestTime, GeoPoint from, GeoPoint to, PtRoutingParameters additionalParameters) { + this.requestTime = requestTime; + this.startingGeoPoint = from; + this.targetGeoPoint = to; + this.routingParameters = additionalParameters; + } + + public long getRequestTime() { + return requestTime; + } + + public GeoPoint getStartingGeoPoint() { + return startingGeoPoint; + } + + public GeoPoint getTargetGeoPoint() { + return targetGeoPoint; + } + + public PtRoutingParameters getRoutingParameters() { + return routingParameters; + } +} diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingResponse.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingResponse.java new file mode 100644 index 000000000..8b5e949da --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingResponse.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +public class PtRoutingResponse { + + private final MultiModalRoute bestRoute; + + public PtRoutingResponse(MultiModalRoute bestRoute) { + this.bestRoute = bestRoute; + } + + public MultiModalRoute getBestRoute() { + return bestRoute; + } +} diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtTimeConversion.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtTimeConversion.java new file mode 100644 index 000000000..8f1173704 --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/PtTimeConversion.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +import org.eclipse.mosaic.rti.TIME; + +import java.time.LocalTime; +import java.util.Date; + +/** + * Contains functions to calculate between different time formats, since "time" is usually always referring to + * simulation time, but a real-world time is needed for the calculation of public transportation routes + */ +public final class PtTimeConversion { + + private static final LocalTime realWorldTime = LocalTime.of(0, 0, 0); + private static final long realWorldTimeNanoS = + TIME.HOUR * realWorldTime.getHour() + + TIME.MINUTE * realWorldTime.getMinute() + + TIME.SECOND * realWorldTime.getSecond(); + + private PtTimeConversion() { + //just need functions to calculate bewtween time formats + } + + public static LocalTime toLocalTime(long simTime) { + return LocalTime.ofNanoOfDay(simTime + realWorldTimeNanoS); + } + + public static long toSimTime(LocalTime time) { + int hourDiff = time.getHour() - realWorldTime.getHour(); + int minuteDiff = time.getMinute() - realWorldTime.getMinute(); + int secondDiff = time.getSecond() - realWorldTime.getSecond(); + + long simTime = TIME.HOUR * hourDiff + TIME.MINUTE * minuteDiff + TIME.SECOND * secondDiff; + + if (simTime < 0) { + System.out.println("Warning, calculated simtime is before sim actually starts"); + } + + return simTime; + } + + public static long toSimTime(Date date) { + return toSimTime(dateToLocalTime(date)); + } + + public static LocalTime dateToLocalTime(Date date) { + if (date == null) { + return null; + } + String[] splitString = date.toString().split(" "); + String[] timeStrings = splitString[3].split(":"); + return LocalTime.of(Integer.parseInt(timeStrings[0]), Integer.parseInt(timeStrings[1]), Integer.parseInt(timeStrings[2])); + } + +} diff --git a/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/WalkLeg.java b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/WalkLeg.java new file mode 100644 index 000000000..9e991a051 --- /dev/null +++ b/lib/mosaic-routing/src/main/java/org/eclipse/mosaic/lib/routing/pt/WalkLeg.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +import org.eclipse.mosaic.lib.geo.GeoPoint; + +import java.util.ArrayList; +import java.util.List; + +public class WalkLeg { + + private final List waypoints = new ArrayList<>(); + + public WalkLeg(List waypoints) { + this.waypoints.addAll(waypoints); + } + + public List getWaypoints() { + return waypoints; + } +} diff --git a/lib/mosaic-routing/src/test/java/org/eclipse/mosaic/lib/routing/database/DatabaseRoutingTest.java b/lib/mosaic-routing/src/test/java/org/eclipse/mosaic/lib/routing/database/DatabaseRoutingTest.java index 66b283cc9..62416a0cf 100644 --- a/lib/mosaic-routing/src/test/java/org/eclipse/mosaic/lib/routing/database/DatabaseRoutingTest.java +++ b/lib/mosaic-routing/src/test/java/org/eclipse/mosaic/lib/routing/database/DatabaseRoutingTest.java @@ -32,7 +32,7 @@ import org.eclipse.mosaic.lib.routing.RoutingPosition; import org.eclipse.mosaic.lib.routing.RoutingRequest; import org.eclipse.mosaic.lib.routing.RoutingResponse; -import org.eclipse.mosaic.lib.routing.config.CRouting; +import org.eclipse.mosaic.lib.routing.config.CVehicleRouting; import org.eclipse.mosaic.rti.api.InternalFederateException; import org.apache.commons.io.FileUtils; @@ -66,7 +66,7 @@ public class DatabaseRoutingTest { private final static String dbFile = "/tiergarten.db"; private DatabaseRouting databaseRouting; - private CRouting configuration; + private CVehicleRouting configuration; private File cfgDir; @@ -80,7 +80,7 @@ public void setup() throws IOException { FileUtils.copyInputStreamToFile(getClass().getResourceAsStream(dbFile), dbFileCopy); - configuration = new CRouting(); + configuration = new CVehicleRouting(); databaseRouting = new DatabaseRouting(); } diff --git a/lib/mosaic-routing/src/test/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingTest.java b/lib/mosaic-routing/src/test/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingTest.java new file mode 100644 index 000000000..d36be2e1f --- /dev/null +++ b/lib/mosaic-routing/src/test/java/org/eclipse/mosaic/lib/routing/pt/PtRoutingTest.java @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2024 Fraunhofer FOKUS and others. All rights reserved. + * + * See the NOTICE file(s) distributed with this work for additional + * information regarding copyright ownership. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0 + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contact: mosaic@fokus.fraunhofer.de + */ + +package org.eclipse.mosaic.lib.routing.pt; + +import static org.junit.Assert.assertEquals; + +import org.eclipse.mosaic.lib.geo.GeoPoint; +import org.eclipse.mosaic.lib.junit.GeoProjectionRule; +import org.eclipse.mosaic.lib.routing.config.CPublicTransportRouting; + +import org.apache.commons.io.FileUtils; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +import java.io.File; +import java.io.IOException; +import java.time.LocalTime; + +public class PtRoutingTest { + + @Rule + public GeoProjectionRule transformationRule = new GeoProjectionRule(GeoPoint.latLon(36.9, -116.7)); + + @Rule + public TemporaryFolder folder = new TemporaryFolder(); + + private PtRouting ptRouting; + private CPublicTransportRouting routingConfiguration; + private File configDir; + + @Before + public void setup() throws IOException { + routingConfiguration = new CPublicTransportRouting(); + routingConfiguration.enabled = true; + routingConfiguration.scheduleDateTime = "2010-01-01T00:00:00"; + routingConfiguration.timeZone = "PST"; + routingConfiguration.osmFile = "pt.osm"; + routingConfiguration.gtfsFile = "pt-gtfs.zip"; + + configDir = folder.newFolder("pt"); + final File osmFileCopy = folder.newFile("pt/" + routingConfiguration.osmFile); + final File gtfsFileCopy = folder.newFile("pt/" + routingConfiguration.gtfsFile); + + FileUtils.copyInputStreamToFile(getClass().getResourceAsStream("/pt/pt.osm"), osmFileCopy); + FileUtils.copyInputStreamToFile(getClass().getResourceAsStream("/pt/pt-gtfs.zip"), gtfsFileCopy); + + ptRouting = new PtRouting(); + } + + @Test(expected = IllegalStateException.class) + public void initialize_skipInitialization() { + routingConfiguration.enabled = false; + ptRouting.initialize(routingConfiguration, configDir); + + // ASSERT + ptRouting.findPtRoute(new PtRoutingRequest(0, GeoPoint.ORIGO, GeoPoint.ORIGO)); + } + + @Test + public void findRoute_walkOnlyCauseIAmFast() { + ptRouting.initialize(routingConfiguration, configDir); + + PtRoutingResponse response = ptRouting.findPtRoute(new PtRoutingRequest( + LocalTime.of(8, 50).toNanoOfDay(), + GeoPoint.latLon(36.900760, -116.766464), + GeoPoint.latLon(36.907353, -116.761829), + new PtRoutingParameters().walkingSpeedKmh(5) + )); + + // ASSERT + MultiModalRoute route = response.getBestRoute(); + assertEquals(1, route.getLegs().size()); + assertEquals(MultiModalLeg.Type.WALKING, route.getLegs().get(0).getLegType()); + } + + @Test + public void findRoute_findPublicTransportRoute() { + ptRouting.initialize(routingConfiguration, configDir); + + PtRoutingResponse response = ptRouting.findPtRoute(new PtRoutingRequest( + LocalTime.of(8, 57).toNanoOfDay(), + GeoPoint.latLon(36.900760, -116.766464), + GeoPoint.latLon(36.907353, -116.761829), + new PtRoutingParameters().walkingSpeedKmh(3) + )); + + // ASSERT + MultiModalRoute route = response.getBestRoute(); + assertEquals(3, route.getLegs().size()); + assertEquals(MultiModalLeg.Type.WALKING, route.getLegs().get(0).getLegType()); + assertEquals(MultiModalLeg.Type.PUBLIC_TRANSPORT, route.getLegs().get(1).getLegType()); + assertEquals(MultiModalLeg.Type.WALKING, route.getLegs().get(2).getLegType()); + } + +} diff --git a/lib/mosaic-routing/src/test/resources/pt/pt-gtfs.zip b/lib/mosaic-routing/src/test/resources/pt/pt-gtfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..2c8238e87c30325318d7939a7c3d5c788eec8734 GIT binary patch literal 1770 zcmWIWW@Zs#-~dA2^4drSD5wF_Tnq{fiRr0%$(4E~6(yk|ybSEzCp^v|`-0E6i-8*i5%<_2@Pu1F6*0*L&bxtxl zC17vWr@|`TXCL6r&av)VRBZ~-QjiM+u)4hgD8mDEdvan~1w{Cdy(Ts(R9ytn6?E1H_Vx@;GpuGFj)2=jEy6r3?JYzpV1E@5x4?gKqR8~Pqi zIqLmQBiv z1v(7mIPA{e3X}l_c~O38Nop~MqyGf2i$x1^-&2lUhYSQ-AJ#4`Kf&mB;f_PIw4%nX zHQpZWQ6AQ+GZ~AkCoX&Nu3lb$qQSSz40T6Tr^M$@xj$t`{GT3CCEdsWqhmlBKA@+HOY#fiOEPnjJSGK<2@u8-8=>6?xta|G zT;4a;Pjc4zav|=hGj~uxG2g*8r7N$NY!>|Wo%do87qjv1&uyG@-L!cG*QH(R@fQ%A zqsYf{`(>r4PZ9rmhT{G8?grN$*NXA|b}yK9U+w{{6zl0_}IN{gXyCQ>GB|7N*6B*=mPo!!)}|G%I<02UjAeIW2?=_w%ql-x_8%XclPitF6)v>la}=Agcb5_OgA%u_B(K7>s(F51 zX@OZqo@sS*9$K2}_LkCXbd@(UEa{wn`lh{!#*q`|CO1s4gdYcICH6yxS2RzCf6&$S z(>;6D@Pgr$hfkS+?quh%-+e435$H0I>jJzPnM9ZoB^Yw~0Lo45XRk;rC)Qa*CZ y0i}Ex*w(1W3^5xswP48y=*A*PEUK{_z)FVbL>S=B$_8=~8xV>B{dxdgLjeF)+#Wsv literal 0 HcmV?d00001 diff --git a/lib/mosaic-routing/src/test/resources/pt/pt.osm b/lib/mosaic-routing/src/test/resources/pt/pt.osm new file mode 100644 index 000000000..c2252f48e --- /dev/null +++ b/lib/mosaic-routing/src/test/resources/pt/pt.osm @@ -0,0 +1,16852 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pom.xml b/pom.xml index 710d30706..5f972d1c8 100644 --- a/pom.xml +++ b/pom.xml @@ -96,11 +96,12 @@ 1.3.9-1 8.0 2.10.1 + 0.0.5 32.1.1-jre 0.8.1 2.16.1 1.3.9 - 2.7.5 + 2.0 1.1.13 0.1.51 1.3.1 @@ -112,6 +113,7 @@ 0.2.16 1.5.0 5.6.0 + 1.0.8 3.23.2 2.0.12 3.42.0.0 @@ -334,10 +336,6 @@ de.westnordost osm-legal-default-speeds-jvm - - org.codehaus.janino - janino - org.apache.xmlgraphics xmlgraphics-commons @@ -352,6 +350,36 @@ + + + com.graphhopper + graphhopper-reader-gtfs + ${version.graphhopper} + + + javax.inject + javax.inject + + + + + + net.sourceforge.javacsv + javacsv + ${version.javacsv} + + + + org.mapdb + mapdb + ${version.mapdb} + + + + io.mobilitydata.transit + gtfs-realtime-bindings + ${version.gtfs-bindings} + com.carrotsearch