How to use org.matsim.core.router

@Override
protected void relaxNode(final Node outNode, final Node toNode, final RouterPriorityQueue<Node> pendingNodes) {
  this.controlCounter++;
  if (this.controlCounter == controlInterval) {
    int newLandmarkIndex = checkToAddLandmark(outNode, toNode);
    if (newLandmarkIndex > 0) {
      updatePendingNodes(newLandmarkIndex, toNode, pendingNodes);
    }
    this.controlCounter = 0;
  }
  
  this.fastRouter.relaxNode(outNode, toNode, pendingNodes);
}
 

@Override
/*package*/ void initFromNode(final Node fromNode, final Node toNode, final double startTime,
    final RouterPriorityQueue<Node> pendingNodes) {
  
  // If it is an imaginary node, we relax it.
  if (fromNode instanceof ImaginaryNode) {			
    relaxImaginaryNode((ImaginaryNode) fromNode, pendingNodes, startTime);
  }
  // ... otherwise: default behaviour.
  else super.initFromNode(fromNode, toNode, startTime, pendingNodes);
}

@Override
public Path calcLeastCostPath(final Node fromNode, final Node toNode, final double startTime, final Person person, final Vehicle vehicle) {
  this.controlCounter = 0;	// reset counter for each calculated path!
  
  if (this.landmarks.length >= 2) {
    initializeActiveLandmarks(fromNode, toNode, 2);
  } else {
    initializeActiveLandmarks(fromNode, toNode, this.landmarks.length);
  }
  return super.calcLeastCostPath(fromNode, toNode, startTime, person, vehicle);
}

  private boolean containsMode( final Subtour s ) {
    for ( Trip t : s.getTrips() ) {
      if ( tripRouter.getMainModeIdentifier().identifyMainMode(
            t.getTripElements() ).equals( mode ) ) {
        return true;
      }
    }
    return false;
  }
}

private boolean containsUnknownMode(final Subtour subtour) {
  for (Trip trip : subtour.getTrips()) {
    if (!modes.contains( mainModeIdentifier.identifyMainMode( trip.getTripElements() ))) {
      return true;
    }
  }
  return false;
}

private String identifyMainMode(final Trip t) {
  return tripRouter.getMainModeIdentifier().identifyMainMode( t.getTripElements() );
}

  @Override
  public PlanAlgorithm createPlanRoutingAlgorithm(
      final TripRouter tripRouter) {
    return new PlanRouter(tripRouter);
  }
});

private MultiNodeDijkstra makeMultiNodeDikstra(Network network, TravelDisutility travelDisutility, TravelTime travelTime,
    boolean fastRouter) {
  if (fastRouter) {
    return (MultiNodeDijkstra) new FastMultiNodeDijkstraFactory().createPathCalculator(network, travelDisutility, travelTime);
  } else return (MultiNodeDijkstra) new MultiNodeDijkstraFactory().createPathCalculator(network, travelDisutility, travelTime);
}

public Trip findTripAfterActivity( Plan plan, Activity activity ) {
  return TripStructureUtils.findTripStartingAtActivity( activity, plan, tripRouter.getStageActivityTypes() ) ;
}

public static Provider<TripRouter> createTripRouterProvider(
    final Scenario scenario,
    final LeastCostPathCalculatorFactory leastCostAlgoFactory,
    final Provider<TransitRouter> transitRouterFactory) {
  TripRouterFactoryBuilderWithDefaults builder = new TripRouterFactoryBuilderWithDefaults();
  builder.setLeastCostPathCalculatorFactory(leastCostAlgoFactory);
  builder.setTransitRouterFactory(transitRouterFactory);
  return builder.build(scenario);
}

private void calculatePaths(Node fromNode, Map<Id<Node>, ToNode> toNodes, double startTime) {
  RoutingNetworkImaginaryNode imaginaryNode = new RoutingNetworkImaginaryNode(toNodes.values());
  multiNodeDijkstra.setSearchAllEndNodes(true);
  multiNodeDijkstra.calcLeastCostPath(fromNode, imaginaryNode, startTime, null, null);
  // get path for each ToNode
  // XXX in most cases we need costs/times, while paths could be constructed lazily only when needed
  // TODO add getCost/Time() to MultiNodeDijkstra
  for (ToNode toNode : toNodes.values()) {
    toNode.path = multiNodeDijkstra.constructPath(fromNode, toNode.node, startTime);
  }
}

@Override
protected void relaxNode(final Node outNode, final Node toNode, final RouterPriorityQueue<Node> pendingNodes) {
  this.controlCounter++;
  if (this.controlCounter == controlInterval) {
    int newLandmarkIndex = checkToAddLandmark(outNode, toNode);
    if (newLandmarkIndex > 0) {
      updatePendingNodes(newLandmarkIndex, toNode, pendingNodes);
    }
    this.controlCounter = 0;
  }
  super.relaxNode(outNode, toNode, pendingNodes);
}

public DynRoutingModule(String mode) {
  this.mode = mode;
  this.stageActivityType = mode + " interaction";
  this.stageActivityTypes = new StageActivityTypesImpl(stageActivityType);
}

protected void relaxImaginaryNode(final ImaginaryNode outNode, final RouterPriorityQueue<Node> pendingNodes,
    final double currTime) {
  
  double currCost = 0.0;	// should be 0
  for (InitialNode initialNode : outNode.initialNodes) {
    double travelTime = initialNode.initialTime;
    double travelCost = initialNode.initialCost;
    DijkstraNodeData data = getData(initialNode.node);
    Link l = null;    // fromLink - use a dummy link here??
    visitNode(initialNode.node, data, pendingNodes, currTime + travelTime, currCost + travelCost, l);			
  }
}    

/**
 * Creates an instance filled with the components passed as parameter
 */
public CompositeStageActivityTypes(
    final StageActivityTypes... components) {
  for ( StageActivityTypes c : components ) {
    addActivityTypes( c );
  }
}

  @Override
  public LeastCostPathCalculatorFactory getFactory(final Network network, final TravelDisutility costCalc, final TravelTime timeCalc) {
    return new FastDijkstraFactory();
  }
});

@Override public boolean equals( Object obj ) {
  if ( !(obj instanceof AccessEgressStageActivityTypes) ) {
    return false ;
  }
  AccessEgressStageActivityTypes other = (AccessEgressStageActivityTypes) obj ;
  return other.isStageActivity(NetworkRoutingInclAccessEgressModule.this.stageActivityType) ;
}
@Override public int hashCode() {

/**
 * Returns the data for the given Node. Creates a new AStarNodeData if none exists yet.
 *
 * @param n The node for which to return the data for..
 * @return The data to the given Node
 */
@Override
protected AStarNodeData getData(final Node n) {
  return (AStarNodeData) super.getData(n);
}

  @Override
  public LeastCostPathCalculatorFactory getFactory(final Network network, final TravelDisutility costCalc, final TravelTime timeCalc) {
    return new FastAStarEuclideanFactory();
  }
});

  @Override
  public String identifyMode(final Subtour subtour) {
    return modeIdentifier.identifyMainMode(
        subtour.getTrips().get( 0 ).getTripElements() );
  }
}