How to use com.graphhopper.routing.ch

NodeBasedNodeContractor(CHGraph prepareGraph, Weighting weighting, PMap pMap) {
  super(prepareGraph, weighting);
  this.prepareWeighting = new PreparationWeighting(weighting);
  extractParams(pMap);
}

public PrepareContractionHierarchies(CHGraph chGraph, Weighting weighting, TraversalMode traversalMode) {
  this.prepareGraph = chGraph;
  this.traversalMode = traversalMode;
  this.weighting = weighting;
  prepareWeighting = new PreparationWeighting(weighting);
  this.params = Params.forTraversalMode(traversalMode);
}

private CalcShortcutsResult calcShortcutCount(int node) {
  findShortcuts(calcScHandler.setNode(node));
  return calcScHandler.calcShortcutsResult;
}

protected void runGraphContraction() {
  if (!prepareNodes())
    return;
  contractNodes();
}

public final boolean isDisablingAllowed() {
  return disablingAllowed || !isEnabled();
}

private Params(int periodicUpdatesPercentage, int lastNodesLazyUpdatePercentage, int neighborUpdatePercentage,
        int nodesContractedPercentage, int logMessagesPercentage) {
  setPeriodicUpdatesPercentage(periodicUpdatesPercentage);
  setLastNodesLazyUpdatePercentage(lastNodesLazyUpdatePercentage);
  setNeighborUpdatePercentage(neighborUpdatePercentage);
  setNodesContractedPercentage(nodesContractedPercentage);
  setLogMessagesPercentage(logMessagesPercentage);
}

private NodeContractor createNodeContractor() {
  NodeContractor nodeContractor = new NodeBasedNodeContractor(lg, weighting, new PMap());
  nodeContractor.initFromGraph();
  nodeContractor.prepareContraction();
  return nodeContractor;
}

@Override
protected final void processEdge(int edgeId, int endNode, int prevEdgeId) {
  // Shortcuts do only contain valid weight so first expand before adding
  // to distance and time
  expandEdge(getEdge(edgeId, endNode), false);
}

  @Override
  public String toString() {
    String str;
    if (flags == PrepareEncoder.getScDirMask())
      str = from + "<->";
    else
      str = from + "->";
    return str + to + ", weight:" + weight + " (" + skippedEdge1 + "," + skippedEdge2 + ")";
  }
}

  @Override
  public String toString() {
    return getName();
  }
}

@Override
public void contractNode(int node) {
  shortcuts.clear();
  long degree = findShortcuts(addScHandler.setNode(node));
  addedShortcutsCount += addShortcuts(shortcuts.keySet());
  // put weight factor on meanDegree instead of taking the average => meanDegree is more stable
  meanDegree = (meanDegree * 2 + degree) / 3;
}

void setLastNodesLazyUpdatePercentage(int lastNodesLazyUpdatePercentage) {
  checkPercentage(LAST_LAZY_NODES_UPDATES, lastNodesLazyUpdatePercentage);
  this.lastNodesLazyUpdatePercentage = lastNodesLazyUpdatePercentage;
}

private void close() {
  nodeContractor.close();
  sortedNodes = null;
  oldPriorities = null;
}

public long getDijkstraCount() {
  return nodeContractor.getDijkstraCount();
}

private float calculatePriority(int node) {
  return nodeContractor.calculatePriority(node);
}

public final boolean isCHEnabled() {
  return chFactoryDecorator.isEnabled();
}

void setLogMessagesPercentage(int logMessagesPercentage) {
  checkPercentage(LOG_MESSAGES, logMessagesPercentage);
  this.logMessagesPercentage = logMessagesPercentage;
}

void setPeriodicUpdatesPercentage(int periodicUpdatesPercentage) {
  checkPercentage(PERIODIC_UPDATES, periodicUpdatesPercentage);
  this.periodicUpdatesPercentage = periodicUpdatesPercentage;
}

void setNodesContractedPercentage(int nodesContractedPercentage) {
  checkPercentage(CONTRACTED_NODES, nodesContractedPercentage);
  this.nodesContractedPercentage = nodesContractedPercentage;
}

void setNeighborUpdatePercentage(int neighborUpdatePercentage) {
  checkPercentage(NEIGHBOR_UPDATES, neighborUpdatePercentage);
  this.neighborUpdatePercentage = neighborUpdatePercentage;
}