If configured, add subway station entrances from OSM to walk steps

application/src/ext-test/java/org/opentripplanner/ext/restapi/mapping/EnumMapperTest.java

@@ -8,39 +8,11 @@
 import java.util.Map;
 import java.util.function.Function;
 import org.junit.jupiter.api.Test;
-import org.opentripplanner.ext.restapi.model.ApiAbsoluteDirection;
-import org.opentripplanner.ext.restapi.model.ApiRelativeDirection;
 import org.opentripplanner.ext.restapi.model.ApiVertexType;
-import org.opentripplanner.model.plan.AbsoluteDirection;
-import org.opentripplanner.model.plan.RelativeDirection;
 import org.opentripplanner.model.plan.VertexType;
 
 public class EnumMapperTest {
 
-  private static final String MSG =
-    "Assert that the API enums have the exact same values that " +
-    "the domain enums of the same type, and that the specialized mapper is mapping all " +
-    "values. If this assumtion does not hold, create a new test.";
-
-  @Test
-  public void map() {
-    try {
-      verifyExactMatch(
-        AbsoluteDirection.class,
-        ApiAbsoluteDirection.class,
-        AbsoluteDirectionMapper::mapAbsoluteDirection
-      );
-      verifyExactMatch(
-        RelativeDirection.class,
-        ApiRelativeDirection.class,
-        RelativeDirectionMapper::mapRelativeDirection
-      );
-    } catch (RuntimeException ex) {
-      System.out.println(MSG);
-      throw ex;
-    }
-  }
-
   @Test
   public void testVertexTypeMapping() {
     verifyExplicitMatch(
@@ -75,17 +47,4 @@ private <D extends Enum<?>, A extends Enum<?>> void verifyExplicitMatch(
     assertTrue(rest.isEmpty());
   }
 
-  private <D extends Enum<?>, A extends Enum<?>> void verifyExactMatch(
-    Class<D> domainClass,
-    Class<A> apiClass,
-    Function<D, A> mapper
-  ) {
-    List<A> rest = new ArrayList<>(List.of(apiClass.getEnumConstants()));
-    for (D it : domainClass.getEnumConstants()) {
-      A result = mapper.apply(it);
-      assertEquals(result.name(), it.name());
-      rest.remove(result);
-    }
-    assertTrue(rest.isEmpty());
-  }
 }

application/src/ext/java/org/opentripplanner/ext/restapi/mapping/RelativeDirectionMapper.java

@@ -14,7 +14,7 @@ public static ApiRelativeDirection mapRelativeDirection(RelativeDirection domain
       case HARD_LEFT -> ApiRelativeDirection.HARD_LEFT;
       case LEFT -> ApiRelativeDirection.LEFT;
       case SLIGHTLY_LEFT -> ApiRelativeDirection.SLIGHTLY_LEFT;
-      case CONTINUE -> ApiRelativeDirection.CONTINUE;
+      case CONTINUE, ENTER_OR_EXIT_STATION -> ApiRelativeDirection.CONTINUE;
       case SLIGHTLY_RIGHT -> ApiRelativeDirection.SLIGHTLY_RIGHT;
       case RIGHT -> ApiRelativeDirection.RIGHT;
       case HARD_RIGHT -> ApiRelativeDirection.HARD_RIGHT;

application/src/ext/java/org/opentripplanner/ext/restapi/mapping/WalkStepMapper.java

@@ -39,7 +39,7 @@ public ApiWalkStep mapWalkStep(WalkStep domain) {
     api.streetName = domain.getDirectionText().toString(locale);
     api.absoluteDirection =
       domain.getAbsoluteDirection().map(AbsoluteDirectionMapper::mapAbsoluteDirection).orElse(null);
-    api.exit = domain.getExit();
+    api.exit = domain.highwayExit().orElse(null);
     api.stayOn = domain.isStayOn();
     api.area = domain.getArea();
     api.bogusName = domain.nameIsDerived();

application/src/main/java/org/opentripplanner/apis/gtfs/GtfsGraphQLIndex.java

@@ -39,6 +39,7 @@
 import org.opentripplanner.apis.gtfs.datafetchers.CurrencyImpl;
 import org.opentripplanner.apis.gtfs.datafetchers.DefaultFareProductImpl;
 import org.opentripplanner.apis.gtfs.datafetchers.DepartureRowImpl;
+import org.opentripplanner.apis.gtfs.datafetchers.EntranceImpl;
 import org.opentripplanner.apis.gtfs.datafetchers.EstimatedTimeImpl;
 import org.opentripplanner.apis.gtfs.datafetchers.FareProductTypeResolver;
 import org.opentripplanner.apis.gtfs.datafetchers.FareProductUseImpl;
@@ -64,6 +65,7 @@
 import org.opentripplanner.apis.gtfs.datafetchers.RouteImpl;
 import org.opentripplanner.apis.gtfs.datafetchers.RouteTypeImpl;
 import org.opentripplanner.apis.gtfs.datafetchers.RoutingErrorImpl;
+import org.opentripplanner.apis.gtfs.datafetchers.StepFeatureTypeResolver;
 import org.opentripplanner.apis.gtfs.datafetchers.StopCallImpl;
 import org.opentripplanner.apis.gtfs.datafetchers.StopGeometriesImpl;
 import org.opentripplanner.apis.gtfs.datafetchers.StopImpl;
@@ -137,6 +139,7 @@ protected static GraphQLSchema buildSchema() {
         .type("AlertEntity", type -> type.typeResolver(new AlertEntityTypeResolver()))
         .type("CallStopLocation", type -> type.typeResolver(new CallStopLocationTypeResolver()))
         .type("CallScheduledTime", type -> type.typeResolver(new CallScheduledTimeTypeResolver()))
+        .type("StepFeature", type -> type.typeResolver(new StepFeatureTypeResolver()))
         .type(typeWiring.build(AgencyImpl.class))
         .type(typeWiring.build(AlertImpl.class))
         .type(typeWiring.build(BikeParkImpl.class))
@@ -195,6 +198,7 @@ protected static GraphQLSchema buildSchema() {
         .type(typeWiring.build(LegTimeImpl.class))
         .type(typeWiring.build(RealTimeEstimateImpl.class))
         .type(typeWiring.build(EstimatedTimeImpl.class))
+        .type(typeWiring.build(EntranceImpl.class))
         .build();
       SchemaGenerator schemaGenerator = new SchemaGenerator();
       return schemaGenerator.makeExecutableSchema(typeRegistry, runtimeWiring);

application/src/main/java/org/opentripplanner/apis/gtfs/datafetchers/EntranceImpl.java

@@ -0,0 +1,45 @@
+package org.opentripplanner.apis.gtfs.datafetchers;
+
+import graphql.schema.DataFetcher;
+import org.opentripplanner.apis.gtfs.GraphQLUtils;
+import org.opentripplanner.apis.gtfs.generated.GraphQLDataFetchers;
+import org.opentripplanner.apis.gtfs.generated.GraphQLTypes;
+import org.opentripplanner.transit.model.site.Entrance;
+
+public class EntranceImpl implements GraphQLDataFetchers.GraphQLEntrance {
+
+  @Override
+  public DataFetcher<String> code() {
+    return environment -> {
+      Entrance entrance = environment.getSource();
+      return entrance.getCode();
+    };
+  }
+
+  @Override
+  public DataFetcher<String> entranceId() {
+    return environment -> {
+      Entrance entrance = environment.getSource();
+      return entrance.getId().toString();
+    };
+  }
+
+  @Override
+  public DataFetcher<String> name() {
+    return environment -> {
+      Entrance entrance = environment.getSource();
+      return org.opentripplanner.framework.graphql.GraphQLUtils.getTranslation(
+        entrance.getName(),
+        environment
+      );
+    };
+  }
+
+  @Override
+  public DataFetcher<GraphQLTypes.GraphQLWheelchairBoarding> wheelchairAccessible() {
+    return environment -> {
+      Entrance entrance = environment.getSource();
+      return GraphQLUtils.toGraphQL(entrance.getWheelchairAccessibility());
+    };
+  }
+}

application/src/main/java/org/opentripplanner/apis/gtfs/datafetchers/StepFeatureTypeResolver.java

@@ -0,0 +1,21 @@
+package org.opentripplanner.apis.gtfs.datafetchers;
+
+import graphql.TypeResolutionEnvironment;
+import graphql.schema.GraphQLObjectType;
+import graphql.schema.GraphQLSchema;
+import graphql.schema.TypeResolver;
+import org.opentripplanner.transit.model.site.Entrance;
+
+public class StepFeatureTypeResolver implements TypeResolver {
+
+  @Override
+  public GraphQLObjectType getType(TypeResolutionEnvironment environment) {
+    Object o = environment.getObject();
+    GraphQLSchema schema = environment.getSchema();
+
+    if (o instanceof Entrance) {
+      return schema.getObjectType("Entrance");
+    }
+    return null;
+  }
+}

application/src/main/java/org/opentripplanner/apis/gtfs/datafetchers/stepImpl.java

@@ -50,7 +50,12 @@ public DataFetcher<Iterable<Step>> elevationProfile() {
 
   @Override
   public DataFetcher<String> exit() {
-    return environment -> getSource(environment).getExit();
+    return environment -> getSource(environment).highwayExit().orElse(null);
+  }
+
+  @Override
+  public DataFetcher<Object> feature() {
+    return environment -> getSource(environment).entrance().orElse(null);
   }
 
   @Override

application/src/main/java/org/opentripplanner/apis/gtfs/generated/GraphQLDataFetchers.java

@@ -392,6 +392,17 @@ public interface GraphQLEmissions {
     public DataFetcher<org.opentripplanner.framework.model.Grams> co2();
   }
 
+  /** Station entrance or exit, originating from OSM or GTFS data. */
+  public interface GraphQLEntrance {
+    public DataFetcher<String> code();
+
+    public DataFetcher<String> entranceId();
+
+    public DataFetcher<String> name();
+
+    public DataFetcher<org.opentripplanner.apis.gtfs.generated.GraphQLTypes.GraphQLWheelchairBoarding> wheelchairAccessible();
+  }
+
   /** Real-time estimates for an arrival or departure at a certain place. */
   public interface GraphQLEstimatedTime {
     public DataFetcher<java.time.Duration> delay();
@@ -1024,6 +1035,9 @@ public interface GraphQLRoutingError {
     public DataFetcher<GraphQLInputField> inputField();
   }
 
+  /** A feature for a step */
+  public interface GraphQLStepFeature extends TypeResolver {}
+
   /**
    * Stop can represent either a single public transport stop, where passengers can
    * board and/or disembark vehicles, or a station, which contains multiple stops.
@@ -1521,6 +1535,8 @@ public interface GraphQLStep {
 
     public DataFetcher<String> exit();
 
+    public DataFetcher<Object> feature();
+
     public DataFetcher<Double> lat();
 
     public DataFetcher<Double> lon();

application/src/main/java/org/opentripplanner/apis/gtfs/mapping/DirectionMapper.java

@@ -27,7 +27,7 @@ public static GraphQLRelativeDirection map(RelativeDirection relativeDirection)
       case HARD_LEFT -> GraphQLRelativeDirection.HARD_LEFT;
       case LEFT -> GraphQLRelativeDirection.LEFT;
       case SLIGHTLY_LEFT -> GraphQLRelativeDirection.SLIGHTLY_LEFT;
-      case CONTINUE -> GraphQLRelativeDirection.CONTINUE;
+      case CONTINUE, ENTER_OR_EXIT_STATION -> GraphQLRelativeDirection.CONTINUE;
       case SLIGHTLY_RIGHT -> GraphQLRelativeDirection.SLIGHTLY_RIGHT;
       case RIGHT -> GraphQLRelativeDirection.RIGHT;
       case HARD_RIGHT -> GraphQLRelativeDirection.HARD_RIGHT;

application/src/main/java/org/opentripplanner/apis/transmodel/model/plan/PathGuidanceType.java

@@ -65,7 +65,9 @@ public static GraphQLObjectType create(GraphQLObjectType elevationStepType) {
           .name("exit")
           .description("When exiting a highway or traffic circle, the exit name/number.")
           .type(Scalars.GraphQLString)
-          .dataFetcher(environment -> ((WalkStep) environment.getSource()).getExit())
+          .dataFetcher(environment ->
+            ((WalkStep) environment.getSource()).highwayExit().orElse(null)
+          )
           .build()
       )
       .field(

application/src/main/java/org/opentripplanner/graph_builder/module/configure/GraphBuilderModules.java

@@ -71,6 +71,7 @@ static OsmModule provideOsmModule(
           osmConfiguredDataSource.dataSource(),
           osmConfiguredDataSource.config().osmTagMapper(),
           osmConfiguredDataSource.config().timeZone(),
+          osmConfiguredDataSource.config().includeOsmSubwayEntrances(),
           config.osmCacheDataInMem,
           issueStore
         )
@@ -86,6 +87,7 @@ static OsmModule provideOsmModule(
       .withStaticBikeParkAndRide(config.staticBikeParkAndRide)
       .withMaxAreaNodes(config.maxAreaNodes)
       .withBoardingAreaRefTags(config.boardingLocationTags)
+      .withIncludeOsmSubwayEntrances(config.osmDefaults.includeOsmSubwayEntrances())
       .withIssueStore(issueStore)
       .withStreetLimitationParameters(streetLimitationParameters)
       .build();

application/src/main/java/org/opentripplanner/graph_builder/module/osm/OsmModule.java

@@ -73,7 +73,13 @@ public class OsmModule implements GraphBuilderModule {
     this.issueStore = issueStore;
     this.params = params;
     this.osmdb = new OsmDatabase(issueStore);
-    this.vertexGenerator = new VertexGenerator(osmdb, graph, params.boardingAreaRefTags());
+    this.vertexGenerator =
+      new VertexGenerator(
+        osmdb,
+        graph,
+        params.boardingAreaRefTags(),
+        params.includeOsmSubwayEntrances()
+      );
     this.normalizer = new SafetyValueNormalizer(graph, issueStore);
     this.streetLimitationParameters = Objects.requireNonNull(streetLimitationParameters);
     this.parkingRepository = parkingService;

application/src/main/java/org/opentripplanner/graph_builder/module/osm/OsmModuleBuilder.java

@@ -26,6 +26,7 @@ public class OsmModuleBuilder {
   private boolean platformEntriesLinking = false;
   private boolean staticParkAndRide = false;
   private boolean staticBikeParkAndRide = false;
+  private boolean includeOsmSubwayEntrances = false;
   private int maxAreaNodes;
   private StreetLimitationParameters streetLimitationParameters = new StreetLimitationParameters();
 
@@ -79,6 +80,11 @@ public OsmModuleBuilder withMaxAreaNodes(int maxAreaNodes) {
     return this;
   }
 
+  public OsmModuleBuilder withIncludeOsmSubwayEntrances(boolean includeOsmSubwayEntrances) {
+    this.includeOsmSubwayEntrances = includeOsmSubwayEntrances;
+    return this;
+  }
+
   public OsmModuleBuilder withStreetLimitationParameters(StreetLimitationParameters parameters) {
     this.streetLimitationParameters = parameters;
     return this;
@@ -98,7 +104,8 @@ public OsmModule build() {
         areaVisibility,
         platformEntriesLinking,
         staticParkAndRide,
-        staticBikeParkAndRide
+        staticBikeParkAndRide,
+        includeOsmSubwayEntrances
       )
     );
   }

application/src/main/java/org/opentripplanner/graph_builder/module/osm/VertexGenerator.java

@@ -33,12 +33,19 @@ class VertexGenerator {
   private final HashMap<Long, Map<OsmLevel, OsmVertex>> multiLevelNodes = new HashMap<>();
   private final OsmDatabase osmdb;
   private final Set<String> boardingAreaRefTags;
+  private final Boolean includeOsmSubwayEntrances;
   private final VertexFactory vertexFactory;
 
-  public VertexGenerator(OsmDatabase osmdb, Graph graph, Set<String> boardingAreaRefTags) {
+  public VertexGenerator(
+    OsmDatabase osmdb,
+    Graph graph,
+    Set<String> boardingAreaRefTags,
+    boolean includeOsmSubwayEntrances
+  ) {
     this.osmdb = osmdb;
     this.vertexFactory = new VertexFactory(graph);
     this.boardingAreaRefTags = boardingAreaRefTags;
+    this.includeOsmSubwayEntrances = includeOsmSubwayEntrances;
   }
 
   /**
@@ -95,6 +102,13 @@ IntersectionVertex getVertexForOsmNode(OsmNode node, OsmWithTags way) {
         iv = bv;
       }
 
+      if (includeOsmSubwayEntrances && node.isSubwayEntrance()) {
+        String ref = node.getTag("ref");
+
+        boolean accessible = node.isTag("wheelchair", "yes");
+        iv = vertexFactory.stationEntrance(nid, coordinate, ref, accessible);
+      }
+
       if (iv == null) {
         iv =
           vertexFactory.osm(

application/src/main/java/org/opentripplanner/graph_builder/module/osm/parameters/OsmExtractParameters.java

@@ -11,16 +11,28 @@
  * Example: {@code "osm" : [ {source: "file:///path/to/otp/norway.pbf"} ] }
  *
  */
-public record OsmExtractParameters(URI source, OsmTagMapperSource osmTagMapper, ZoneId timeZone)
+public record OsmExtractParameters(
+  URI source,
+  OsmTagMapperSource osmTagMapper,
+  ZoneId timeZone,
+  boolean includeOsmSubwayEntrances
+)
   implements DataSourceConfig {
   public static final OsmTagMapperSource DEFAULT_OSM_TAG_MAPPER = OsmTagMapperSource.DEFAULT;
 
   public static final ZoneId DEFAULT_TIME_ZONE = null;
 
+  public static final boolean DEFAULT_INCLUDE_OSM_SUBWAY_ENTRANCES = false;
+
   public static final OsmExtractParameters DEFAULT = new OsmExtractParametersBuilder().build();
 
   OsmExtractParameters(OsmExtractParametersBuilder builder) {
-    this(builder.getSource(), builder.getOsmTagMapper(), builder.getTimeZone());
+    this(
+      builder.getSource(),
+      builder.getOsmTagMapper(),
+      builder.getTimeZone(),
+      builder.includeOsmSubwayEntrances()
+    );
   }
 
   @Override
@@ -37,6 +49,10 @@ public ZoneId timeZone() {
     return timeZone;
   }
 
+  public boolean includeOsmSubwayEntrances() {
+    return includeOsmSubwayEntrances;
+  }
+
   public OsmExtractParametersBuilder copyOf() {
     return new OsmExtractParametersBuilder(this);
   }