@Override public boolean isForward(FlagEncoder encoder) { return encoder.isForward(getFlags()); }
/** * Reports whether the edge is available in forward direction for the specified encoder. */ @Override public boolean isForward(FlagEncoder encoder) { return encoder.isForward(getDirectFlags()); }
@Override public long calcMillis(EdgeIteratorState edgeState, boolean reverse, int prevOrNextEdgeId) { long flags = edgeState.getFlags(); if (reverse && !flagEncoder.isBackward(flags) || !reverse && !flagEncoder.isForward(flags)) throw new IllegalStateException("Calculating time should not require to read speed from edge in wrong direction. " + "Reverse:" + reverse + ", fwd:" + flagEncoder.isForward(flags) + ", bwd:" + flagEncoder.isBackward(flags)); double speed = reverse ? flagEncoder.getReverseSpeed(flags) : flagEncoder.getSpeed(flags); if (Double.isInfinite(speed) || Double.isNaN(speed) || speed < 0) throw new IllegalStateException("Invalid speed stored in edge! " + speed); if (speed == 0) throw new IllegalStateException("Speed cannot be 0 for unblocked edge, use access properties to mark edge blocked! Should only occur for shortest path calculation. See #242."); return (long) (edgeState.getDistance() * 3600 / speed); }
@Override protected final boolean checkAdjacent(EdgeIteratorState edge) { if (encoder.isForward(edge.getFlags()) || encoder.isBackward(edge.getFlags())) { tmpCounter++; return true; } return false; }
@Override public boolean accept(EdgeIteratorState edgeState) { return flagEncoder.isForward(edgeState.getFlags()) && flagEncoder.isBackward(edgeState.getFlags()); } }
public InstructionsOutgoingEdges(EdgeIteratorState prevEdge, EdgeIteratorState currentEdge, FlagEncoder encoder, EdgeExplorer crossingExplorer, NodeAccess nodeAccess, int prevNode, int baseNode, int adjNode) { this.prevEdge = prevEdge; this.currentEdge = currentEdge; this.encoder = encoder; this.nodeAccess = nodeAccess; EdgeIteratorState tmpEdge; allOutgoingEdges = new ArrayList<>(); allowedOutgoingEdges = new ArrayList<>(); EdgeIterator edgeIter = crossingExplorer.setBaseNode(baseNode); while (edgeIter.next()) { if (edgeIter.getAdjNode() != prevNode && edgeIter.getAdjNode() != adjNode) { tmpEdge = edgeIter.detach(false); allOutgoingEdges.add(tmpEdge); if (encoder.isForward(tmpEdge.getFlags())) { allowedOutgoingEdges.add(tmpEdge); } } } }
@Override public boolean isForward(FlagEncoder encoder) { assert encoder == weighting.getFlagEncoder() : encoder + " vs. " + weighting.getFlagEncoder(); if (isShortcut()) return (getDirectFlags() & PrepareEncoder.getScFwdDir()) != 0; return encoder.isForward(getDirectFlags()); }
@Override public boolean isForward(FlagEncoder encoder) { assert encoder == weighting.getFlagEncoder() : encoder + " vs. " + weighting.getFlagEncoder(); if (isShortcut()) return (getDirectFlags() & PrepareEncoder.getScFwdDir()) != 0; return encoder.isForward(getDirectFlags()); }
/** * This method checks if the node is removed or inaccessible for ALL encoders. * <p> * * @return true if no edges are reachable from the specified nodeIndex for any flag encoder. */ boolean detectNodeRemovedForAllEncoders(EdgeExplorer edgeExplorerAllEdges, int nodeIndex) { // we could implement a 'fast check' for several previously marked removed nodes via GHBitSet // removedNodesPerVehicle. The problem is that we would need long-indices but BitSet only supports int (due to nodeIndex*numberOfEncoders) // if no edges are reachable return true EdgeIterator iter = edgeExplorerAllEdges.setBaseNode(nodeIndex); while (iter.next()) { // if at least on encoder allows one direction return false for (FlagEncoder encoder : encoders) { if (encoder.isBackward(iter.getFlags()) || encoder.isForward(iter.getFlags())) return false; } } return true; }
@Override public boolean test(EdgeIteratorState edgeIterator) { final GtfsStorage.EdgeType edgeType = flagEncoder.getEdgeType(edgeIterator.getFlags()); if (edgeType == GtfsStorage.EdgeType.HIGHWAY) { if (reverse) { return accessEgressWeighting.getFlagEncoder().isBackward(edgeIterator.getFlags()); } else { return accessEgressWeighting.getFlagEncoder().isForward(edgeIterator.getFlags()); } } if (walkOnly && edgeType != (reverse ? GtfsStorage.EdgeType.EXIT_PT : GtfsStorage.EdgeType.ENTER_PT)) { return false; } if (!isValidOn(edgeIterator, label.currentTime)) { return false; } if (edgeType == GtfsStorage.EdgeType.WAIT_ARRIVAL && !reverse) { return false; } return true; } }
boolean fwd = encoder.isForward(edge.getFlags()); boolean bwd = encoder.isBackward(edge.getFlags()); float width = speed > 90 ? 1f : 0.8f;
String toString(FlagEncoder encoder, EdgeIterator iter) { String str = ""; while (iter.next()) { int adjNode = iter.getAdjNode(); str += adjNode + " (" + ghStorage.getNodeAccess().getLat(adjNode) + "," + ghStorage.getNodeAccess().getLon(adjNode) + "), "; str += "speed (fwd:" + encoder.getSpeed(iter.getFlags()) + ", rev:" + encoder.getReverseSpeed(iter.getFlags()) + "), "; str += "access (fwd:" + encoder.isForward(iter.getFlags()) + ", rev:" + encoder.isBackward(iter.getFlags()) + "), "; str += "distance:" + iter.getDistance(); str += ";\n "; } return str; }
@Test public void testCombination() { ReaderWay way = new ReaderWay(123); way.setTag("highway", "cycleway"); way.setTag("sac_scale", "hiking"); long flags = em.acceptWay(way); long edgeFlags = em.handleWayTags(way, flags, 0); assertFalse(encoder.isBackward(edgeFlags)); assertFalse(encoder.isForward(edgeFlags)); assertTrue(em.getEncoder("bike").isBackward(edgeFlags)); assertTrue(em.getEncoder("bike").isForward(edgeFlags)); }
@Test public void testCombined() { FlagEncoder carEncoder = encodingManager.getEncoder("car"); long fl = footEncoder.setProperties(10, true, true) | carEncoder.setProperties(100, true, false); assertEquals(10, footEncoder.getSpeed(fl), 1e-1); assertTrue(footEncoder.isForward(fl)); assertTrue(footEncoder.isBackward(fl)); assertEquals(100, carEncoder.getSpeed(fl), 1e-1); assertTrue(carEncoder.isForward(fl)); assertFalse(carEncoder.isBackward(fl)); assertEquals(0, carEncoder.getSpeed(footEncoder.setProperties(10, true, true)), 1e-1); }
/** * Reports whether the edge is available in forward direction for the specified encoder. */ @Override public boolean isForward( FlagEncoder encoder ) { return encoder.isForward(getDirectFlags()); }
/** * Reports whether the edge is available in forward direction for the specified encoder. */ @Override public boolean isForward(FlagEncoder encoder) { return encoder.isForward(getDirectFlags()); }
@Override public boolean isForward(FlagEncoder encoder) { assert encoder == weighting.getFlagEncoder() : encoder + " vs. " + weighting.getFlagEncoder(); if (isShortcut()) return (getDirectFlags() & PrepareEncoder.getScFwdDir()) != 0; return encoder.isForward(getDirectFlags()); }
@Override public boolean isForward(FlagEncoder encoder) { assert encoder == weighting.getFlagEncoder() : encoder + " vs. " + weighting.getFlagEncoder(); if (isShortcut()) return (getDirectFlags() & PrepareEncoder.getScFwdDir()) != 0; return encoder.isForward(getDirectFlags()); }
String toString(FlagEncoder encoder, EdgeIterator iter) { String str = ""; while (iter.next()) { int adjNode = iter.getAdjNode(); str += adjNode + " (" + ghStorage.getNodeAccess().getLat(adjNode) + "," + ghStorage.getNodeAccess().getLon(adjNode) + "), "; str += "speed (fwd:" + encoder.getSpeed(iter.getFlags()) + ", rev:" + encoder.getReverseSpeed(iter.getFlags()) + "), "; str += "access (fwd:" + encoder.isForward(iter.getFlags()) + ", rev:" + encoder.isBackward(iter.getFlags()) + "), "; str += "distance:" + iter.getDistance(); str += ";\n "; } return str; }