org.opentripplanner.graph_builder.module.configure.GraphBuilderModules Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of otp Show documentation
The OpenTripPlanner multimodal journey planning system
The newest version!
package org.opentripplanner.graph_builder.module.configure;

import static org.opentripplanner.datastore.api.FileType.DEM;

import dagger.Module;
import dagger.Provides;
import jakarta.inject.Singleton;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Nullable;
import org.opentripplanner.datastore.api.DataSource;
import org.opentripplanner.ext.dataoverlay.EdgeUpdaterModule;
import org.opentripplanner.ext.dataoverlay.configure.DataOverlayFactory;
import org.opentripplanner.ext.emissions.EmissionsDataModel;
import org.opentripplanner.ext.emissions.EmissionsModule;
import org.opentripplanner.ext.stopconsolidation.StopConsolidationModule;
import org.opentripplanner.ext.stopconsolidation.StopConsolidationRepository;
import org.opentripplanner.ext.transferanalyzer.DirectTransferAnalyzer;
import org.opentripplanner.graph_builder.ConfiguredDataSource;
import org.opentripplanner.graph_builder.GraphBuilderDataSources;
import org.opentripplanner.graph_builder.issue.api.DataImportIssueStore;
import org.opentripplanner.graph_builder.issue.api.DataImportIssueSummary;
import org.opentripplanner.graph_builder.issue.report.DataImportIssueReporter;
import org.opentripplanner.graph_builder.issue.service.DefaultDataImportIssueStore;
import org.opentripplanner.graph_builder.module.DirectTransferGenerator;
import org.opentripplanner.graph_builder.module.StreetLinkerModule;
import org.opentripplanner.graph_builder.module.islandpruning.PruneIslands;
import org.opentripplanner.graph_builder.module.ned.DegreeGridNEDTileSource;
import org.opentripplanner.graph_builder.module.ned.ElevationModule;
import org.opentripplanner.graph_builder.module.ned.GeotiffGridCoverageFactoryImpl;
import org.opentripplanner.graph_builder.module.ned.NEDGridCoverageFactoryImpl;
import org.opentripplanner.graph_builder.module.ned.parameter.DemExtractParameters;
import org.opentripplanner.graph_builder.module.osm.OsmModule;
import org.opentripplanner.graph_builder.module.osm.parameters.OsmExtractParameters;
import org.opentripplanner.graph_builder.services.ned.ElevationGridCoverageFactory;
import org.opentripplanner.gtfs.graphbuilder.GtfsBundle;
import org.opentripplanner.gtfs.graphbuilder.GtfsFeedParameters;
import org.opentripplanner.gtfs.graphbuilder.GtfsModule;
import org.opentripplanner.netex.NetexModule;
import org.opentripplanner.netex.configure.NetexConfigure;
import org.opentripplanner.openstreetmap.OsmProvider;
import org.opentripplanner.routing.api.request.preference.WalkPreferences;
import org.opentripplanner.routing.graph.Graph;
import org.opentripplanner.standalone.config.BuildConfig;
import org.opentripplanner.street.model.StreetLimitationParameters;
import org.opentripplanner.transit.service.TransitModel;

/**
 * Configure all modules which is not simple enough to be injected.
 */
@Module
public class GraphBuilderModules {

  @Provides
  @Singleton
  static OsmModule provideOpenStreetMapModule(
    GraphBuilderDataSources dataSources,
    BuildConfig config,
    Graph graph,
    DataImportIssueStore issueStore,
    StreetLimitationParameters streetLimitationParameters
  ) {
    List providers = new ArrayList<>();
    for (ConfiguredDataSource osmConfiguredDataSource : dataSources.getOsmConfiguredDatasource()) {
      providers.add(
        new OsmProvider(
          osmConfiguredDataSource.dataSource(),
          osmConfiguredDataSource.config().osmTagMapper(),
          osmConfiguredDataSource.config().timeZone(),
          config.osmCacheDataInMem,
          issueStore
        )
      );
    }

    return OsmModule
      .of(providers, graph)
      .withEdgeNamer(config.edgeNamer)
      .withAreaVisibility(config.areaVisibility)
      .withPlatformEntriesLinking(config.platformEntriesLinking)
      .withStaticParkAndRide(config.staticParkAndRide)
      .withStaticBikeParkAndRide(config.staticBikeParkAndRide)
      .withMaxAreaNodes(config.maxAreaNodes)
      .withBoardingAreaRefTags(config.boardingLocationTags)
      .withIssueStore(issueStore)
      .withStreetLimitationParameters(streetLimitationParameters)
      .build();
  }

  @Provides
  @Singleton
  static GtfsModule provideGtfsModule(
    GraphBuilderDataSources dataSources,
    BuildConfig config,
    Graph graph,
    TransitModel transitModel,
    DataImportIssueStore issueStore
  ) {
    List gtfsBundles = new ArrayList<>();
    for (ConfiguredDataSource gtfsData : dataSources.getGtfsConfiguredDatasource()) {
      GtfsBundle gtfsBundle = new GtfsBundle(gtfsData);

      gtfsBundle.subwayAccessTime = config.getSubwayAccessTimeSeconds();
      gtfsBundle.setMaxStopToShapeSnapDistance(config.maxStopToShapeSnapDistance);
      gtfsBundles.add(gtfsBundle);
    }
    return new GtfsModule(
      gtfsBundles,
      transitModel,
      graph,
      issueStore,
      config.getTransitServicePeriod(),
      config.fareServiceFactory
    );
  }

  @Provides
  @Singleton
  static EmissionsModule provideEmissionsModule(
    GraphBuilderDataSources dataSources,
    BuildConfig config,
    @Nullable EmissionsDataModel emissionsDataModel,
    DataImportIssueStore issueStore
  ) {
    return new EmissionsModule(
      dataSources.getGtfsConfiguredDatasource(),
      config,
      emissionsDataModel,
      issueStore
    );
  }

  @Provides
  @Singleton
  static NetexModule provideNetexModule(
    GraphBuilderDataSources dataSources,
    BuildConfig config,
    Graph graph,
    TransitModel transitModel,
    DataImportIssueStore issueStore
  ) {
    return new NetexConfigure(config)
      .createNetexModule(
        dataSources.getNetexConfiguredDatasource(),
        transitModel,
        graph,
        issueStore
      );
  }

  @Provides
  @Singleton
  static StreetLinkerModule provideStreetLinkerModule(
    BuildConfig config,
    Graph graph,
    TransitModel transitModel,
    DataImportIssueStore issueStore
  ) {
    return new StreetLinkerModule(graph, transitModel, issueStore, config.areaVisibility);
  }

  @Provides
  @Singleton
  static PruneIslands providePruneIslands(
    BuildConfig config,
    Graph graph,
    TransitModel transitModel,
    DataImportIssueStore issueStore
  ) {
    PruneIslands pruneIslands = new PruneIslands(
      graph,
      transitModel,
      issueStore,
      new StreetLinkerModule(graph, transitModel, issueStore, config.areaVisibility)
    );
    pruneIslands.setPruningThresholdIslandWithoutStops(
      config.islandPruning.pruningThresholdIslandWithoutStops
    );
    pruneIslands.setPruningThresholdIslandWithStops(
      config.islandPruning.pruningThresholdIslandWithStops
    );
    pruneIslands.setAdaptivePruningFactor(config.islandPruning.adaptivePruningFactor);
    pruneIslands.setAdaptivePruningDistance(config.islandPruning.adaptivePruningDistance);
    return pruneIslands;
  }

  @Provides
  @Singleton
  static List provideElevationModules(
    BuildConfig config,
    GraphBuilderDataSources dataSources,
    Graph graph,
    OsmModule osmModule,
    DataImportIssueStore issueStore
  ) {
    List result = new ArrayList<>();
    List gridCoverageFactories = new ArrayList<>();
    if (config.elevationBucket != null) {
      gridCoverageFactories.add(
        createNedElevationFactory(new File(dataSources.getCacheDirectory(), "ned"), config)
      );
    } else if (dataSources.has(DEM)) {
      gridCoverageFactories.addAll(
        createDemGeotiffGridCoverageFactories(dataSources.getDemConfiguredDatasource())
      );
    }
    // Refactoring this class, it was made clear that this allows for adding multiple elevation
    // modules to the same graph builder. We do not actually know if this is supported by the
    // ElevationModule class.
    for (ElevationGridCoverageFactory it : gridCoverageFactories) {
      result.add(
        createElevationModule(
          config,
          graph,
          issueStore,
          it,
          osmModule,
          dataSources.getCacheDirectory()
        )
      );
    }
    return result;
  }

  @Provides
  @Singleton
  static DirectTransferGenerator provideDirectTransferGenerator(
    BuildConfig config,
    Graph graph,
    TransitModel transitModel,
    DataImportIssueStore issueStore
  ) {
    return new DirectTransferGenerator(
      graph,
      transitModel,
      issueStore,
      config.maxTransferDuration,
      config.transferRequests
    );
  }

  @Provides
  @Singleton
  static DirectTransferAnalyzer provideDirectTransferAnalyzer(
    BuildConfig config,
    Graph graph,
    TransitModel transitModel,
    DataImportIssueStore issueStore
  ) {
    return new DirectTransferAnalyzer(
      graph,
      transitModel,
      issueStore,
      config.maxTransferDuration.toSeconds() * WalkPreferences.DEFAULT.speed()
    );
  }

  @Provides
  @Singleton
  static EdgeUpdaterModule provideDataOverlayFactory(BuildConfig config, Graph graph) {
    return DataOverlayFactory.create(graph, config.dataOverlay);
  }

  @Provides
  @Singleton
  static DataImportIssueStore provideDataImportIssuesStore() {
    return new DefaultDataImportIssueStore();
  }

  @Provides
  @Singleton
  static DataImportIssueReporter provideDataImportIssuesToHTML(
    GraphBuilderDataSources dataSources,
    BuildConfig config,
    DataImportIssueStore issueStore
  ) {
    return new DataImportIssueReporter(
      issueStore,
      dataSources.getBuildReportDir(),
      config.maxDataImportIssuesPerFile
    );
  }

  @Provides
  @Singleton
  static DataImportIssueSummary providesDataImportIssueSummary(DataImportIssueStore issueStore) {
    return new DataImportIssueSummary(issueStore.listIssues());
  }

  @Provides
  @Singleton
  @Nullable
  static StopConsolidationModule providesStopConsolidationModule(
    TransitModel transitModel,
    @Nullable StopConsolidationRepository repo,
    GraphBuilderDataSources dataSources
  ) {
    return dataSources
      .stopConsolidation()
      .map(ds -> StopConsolidationModule.of(transitModel, repo, ds))
      .orElse(null);
  }

  /* private methods */

  private static ElevationGridCoverageFactory createNedElevationFactory(
    File nedCacheDirectory,
    BuildConfig config
  ) {
    // Download the elevation tiles from an Amazon S3 bucket
    DegreeGridNEDTileSource awsTileSource = new DegreeGridNEDTileSource();
    awsTileSource.awsAccessKey = config.elevationBucket.accessKey;
    awsTileSource.awsSecretKey = config.elevationBucket.secretKey;
    awsTileSource.awsBucketName = config.elevationBucket.bucketName;

    return new NEDGridCoverageFactoryImpl(nedCacheDirectory, awsTileSource);
  }

  private static List createDemGeotiffGridCoverageFactories(
    Iterable> dataSources
  ) {
    List elevationGridCoverageFactories = new ArrayList<>();
    for (ConfiguredDataSource demSource : dataSources) {
      double elevationUnitMultiplier = demSource.config().elevationUnitMultiplier();
      elevationGridCoverageFactories.add(
        createGeotiffGridCoverageFactoryImpl(demSource.dataSource(), elevationUnitMultiplier)
      );
    }
    return elevationGridCoverageFactories;
  }

  private static ElevationModule createElevationModule(
    BuildConfig config,
    Graph graph,
    DataImportIssueStore issueStore,
    ElevationGridCoverageFactory it,
    OsmModule osmModule,
    File cacheDirectory
  ) {
    var cachedElevationsFile = new File(cacheDirectory, "cached_elevations.obj");

    return new ElevationModule(
      it,
      graph,
      issueStore,
      cachedElevationsFile,
      osmModule.elevationDataOutput(),
      config.readCachedElevations,
      config.writeCachedElevations,
      config.distanceBetweenElevationSamples,
      config.maxElevationPropagationMeters,
      config.includeEllipsoidToGeoidDifference,
      config.multiThreadElevationCalculations
    );
  }

  private static ElevationGridCoverageFactory createGeotiffGridCoverageFactoryImpl(
    DataSource demSource,
    double elevationUnitMultiplier
  ) {
    return new GeotiffGridCoverageFactoryImpl(demSource, elevationUnitMultiplier);
  }
}