org.opentripplanner.street.search.StreetSearchBuilder 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.street.search;

import java.time.Duration;
import java.util.Collection;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opentripplanner.astar.AStarBuilder;
import org.opentripplanner.astar.spi.DominanceFunction;
import org.opentripplanner.astar.spi.RemainingWeightHeuristic;
import org.opentripplanner.ext.dataoverlay.routing.DataOverlayContext;
import org.opentripplanner.routing.api.request.RouteRequest;
import org.opentripplanner.routing.api.request.preference.StreetPreferences;
import org.opentripplanner.routing.api.request.request.StreetRequest;
import org.opentripplanner.street.model.edge.Edge;
import org.opentripplanner.street.model.vertex.Vertex;
import org.opentripplanner.street.search.intersection_model.IntersectionTraversalCalculator;
import org.opentripplanner.street.search.request.StreetSearchRequest;
import org.opentripplanner.street.search.request.StreetSearchRequestMapper;
import org.opentripplanner.street.search.state.State;
import org.opentripplanner.street.search.strategy.DominanceFunctions;
import org.opentripplanner.street.search.strategy.EuclideanRemainingWeightHeuristic;

public class StreetSearchBuilder extends AStarBuilder {

  private RouteRequest routeRequest;
  private StreetRequest streetRequest = new StreetRequest();
  private IntersectionTraversalCalculator intersectionTraversalCalculator;
  private DataOverlayContext dataOverlayContext;

  public static StreetSearchBuilder of() {
    return new StreetSearchBuilder();
  }

  private StreetSearchBuilder() {
    super();
    setBuilder(this);
  }

  public StreetSearchBuilder setRequest(RouteRequest request) {
    this.routeRequest = request;
    setArriveBy(request.arriveBy());
    return this;
  }

  public StreetSearchBuilder setStreetRequest(StreetRequest streetRequest) {
    this.streetRequest = streetRequest;
    return this;
  }

  public StreetSearchBuilder setVerticesContainer(TemporaryVerticesContainer container) {
    setFrom(container.getFromVertices());
    setTo(container.getToVertices());
    return this;
  }

  public StreetSearchBuilder setIntersectionTraversalCalculator(
    IntersectionTraversalCalculator intersectionTraversalCalculator
  ) {
    this.intersectionTraversalCalculator = intersectionTraversalCalculator;
    return this;
  }

  public StreetSearchBuilder setDataOverlayContext(DataOverlayContext dataOverlayContext) {
    this.dataOverlayContext = dataOverlayContext;
    return this;
  }

  @Nonnull
  @Override
  protected Duration streetRoutingTimeout() {
    return routeRequest.preferences().street().routingTimeout();
  }

  @Override
  protected Collection createInitialStates(Set originVertices) {
    StreetSearchRequest streetSearchRequest = StreetSearchRequestMapper
      .map(routeRequest)
      .withMode(streetRequest.mode())
      .withArriveBy(arriveBy())
      .build();

    return State.getInitialStates(originVertices, streetSearchRequest);
  }

  @Override
  protected void prepareInitialStates(Collection initialStates) {
    if (intersectionTraversalCalculator == null) {
      final StreetPreferences streetPreferences = routeRequest.preferences().street();
      intersectionTraversalCalculator =
        IntersectionTraversalCalculator.create(
          streetPreferences.intersectionTraversalModel(),
          streetPreferences.drivingDirection()
        );
    }

    for (var state : initialStates) {
      state.getRequest().setIntersectionTraversalCalculator(intersectionTraversalCalculator);
      state.getRequest().setDataOverlayContext(dataOverlayContext);
    }
  }

  @Override
  protected void initializeHeuristic(
    RemainingWeightHeuristic heuristic,
    Set ignored,
    Set destination,
    boolean arriveBy
  ) {
    if (heuristic.equals(RemainingWeightHeuristic.TRIVIAL)) {
      // No initialization needed
    } else if (heuristic instanceof EuclideanRemainingWeightHeuristic euclideanHeuristic) {
      euclideanHeuristic.initialize(
        streetRequest.mode(),
        destination,
        arriveBy,
        routeRequest.preferences()
      );
    } else {
      throw new IllegalArgumentException("Unknown heuristic type: " + heuristic);
    }
  }

  @Override
  protected DominanceFunction createDefaultDominanceFunction() {
    return new DominanceFunctions.Pareto();
  }
}