/** * Accepts all edges that are either forward or backward for the given flag encoder. * Edges where neither one of the flags is enabled will still not be accepted. If you need to retrieve all edges * regardless of their encoding use {@link EdgeFilter#ALL_EDGES} instead. */ public static DefaultEdgeFilter allEdges(FlagEncoder flagEncoder) { return new DefaultEdgeFilter(flagEncoder, true, true); }
@Override public List<QueryResult> lookup(List<GHPoint> points, FlagEncoder encoder) { if (points.size() < 2) throw new IllegalArgumentException("At least 2 points have to be specified, but was:" + points.size()); EdgeFilter edgeFilter = DefaultEdgeFilter.allEdges(encoder); queryResults = new ArrayList<>(points.size()); for (int placeIndex = 0; placeIndex < points.size(); placeIndex++) { GHPoint point = points.get(placeIndex); QueryResult qr = null; if (ghRequest.hasPointHints()) qr = locationIndex.findClosest(point.lat, point.lon, new NameSimilarityEdgeFilter(edgeFilter, ghRequest.getPointHints().get(placeIndex))); if (qr == null || !qr.isValid()) qr = locationIndex.findClosest(point.lat, point.lon, edgeFilter); if (!qr.isValid()) ghResponse.addError(new PointNotFoundException("Cannot find point " + placeIndex + ": " + point, placeIndex)); queryResults.add(qr); } return queryResults; }
public Collection<TurnCostTableEntry> analyzeTurnRelation(FlagEncoder encoder, OSMTurnRelation turnRelation) { if (!encoder.supports(TurnWeighting.class)) return Collections.emptyList(); EdgeExplorer edgeOutExplorer = outExplorerMap.get(encoder); EdgeExplorer edgeInExplorer = inExplorerMap.get(encoder); if (edgeOutExplorer == null || edgeInExplorer == null) { edgeOutExplorer = graph.createEdgeExplorer(DefaultEdgeFilter.outEdges(encoder)); outExplorerMap.put(encoder, edgeOutExplorer); edgeInExplorer = graph.createEdgeExplorer(DefaultEdgeFilter.inEdges(encoder)); inExplorerMap.put(encoder, edgeInExplorer); } return turnRelation.getRestrictionAsEntries(encoder, edgeOutExplorer, edgeInExplorer, this); }
@Override public EdgeExplorer createEdgeExplorer(final EdgeFilter edgeFilter) { if (!isInitialized()) throw new IllegalStateException("Call lookup before using this graph"); if (useEdgeExplorerCache) { int counter = -1; if (edgeFilter instanceof DefaultEdgeFilter) { DefaultEdgeFilter dee = (DefaultEdgeFilter) edgeFilter; counter = 0; if (dee.acceptsBackward()) counter = 1; if (dee.acceptsForward()) counter += 2; if (counter == 0) throw new IllegalStateException("You tried to use an edge filter blocking every access"); } else if (edgeFilter == EdgeFilter.ALL_EDGES) { counter = 4; } if (counter >= 0) { EdgeExplorer cached = cacheMap.get(counter); if (cached == null) { cached = createUncachedEdgeExplorer(edgeFilter); cacheMap.put(counter, cached); } return cached; } } return createUncachedEdgeExplorer(edgeFilter); }
public InstructionsFromEdges(int tmpNode, Graph graph, Weighting weighting, FlagEncoder encoder, NodeAccess nodeAccess, Translation tr, InstructionList ways) { this.weighting = weighting; this.encoder = encoder; this.nodeAccess = nodeAccess; this.tr = tr; this.ways = ways; prevLat = this.nodeAccess.getLatitude(tmpNode); prevLon = this.nodeAccess.getLongitude(tmpNode); prevNode = -1; prevInRoundabout = false; prevName = null; outEdgeExplorer = graph.createEdgeExplorer(DefaultEdgeFilter.outEdges(encoder)); crossingExplorer = graph.createEdgeExplorer(DefaultEdgeFilter.allEdges(encoder)); }
private NavigableMap<Integer, Integer> findDepartureTimelineForPlatform(int platformEnterNode) { TreeMap<Integer, Integer> result = new TreeMap<>(); if (platformEnterNode == -1) { return result; } EdgeIterator edge = graph.getBaseGraph().createEdgeExplorer(DefaultEdgeFilter.outEdges(encoder)).setBaseNode(platformEnterNode); while (edge.next()) { if (encoder.getEdgeType(edge.getFlags()) == GtfsStorage.EdgeType.ENTER_TIME_EXPANDED_NETWORK) { result.put((int) encoder.getTime(edge.getFlags()), edge.getAdjNode()); } } return result; }
public GraphExplorer(Graph graph, Weighting accessEgressWeighting, PtFlagEncoder flagEncoder, GtfsStorage gtfsStorage, RealtimeFeed realtimeFeed, boolean reverse, List<VirtualEdgeIteratorState> extraEdges, boolean walkOnly, double walkSpeedKmh) { this.graph = graph; this.accessEgressWeighting = accessEgressWeighting; DefaultEdgeFilter accessEgressIn = DefaultEdgeFilter.inEdges(accessEgressWeighting.getFlagEncoder()); DefaultEdgeFilter accessEgressOut = DefaultEdgeFilter.outEdges(accessEgressWeighting.getFlagEncoder()); DefaultEdgeFilter ptIn = DefaultEdgeFilter.inEdges(flagEncoder); DefaultEdgeFilter ptOut = DefaultEdgeFilter.outEdges(flagEncoder); EdgeFilter in = edgeState -> accessEgressIn.accept(edgeState) || ptIn.accept(edgeState); EdgeFilter out = edgeState -> accessEgressOut.accept(edgeState) || ptOut.accept(edgeState); this.edgeExplorer = graph.createEdgeExplorer(reverse ? in : out); this.flagEncoder = flagEncoder; this.gtfsStorage = gtfsStorage; this.realtimeFeed = realtimeFeed; this.reverse = reverse; this.extraEdges.addAll(extraEdges); for (VirtualEdgeIteratorState extraEdge : extraEdges) { if (extraEdge == null) { throw new RuntimeException(); } extraEdgesBySource.put(extraEdge.getBaseNode(), extraEdge); extraEdgesByDestination.put(extraEdge.getAdjNode(), new VirtualEdgeIteratorState(extraEdge.getOriginalTraversalKey(), extraEdge.getEdge(), extraEdge.getAdjNode(), extraEdge.getBaseNode(), extraEdge.getDistance(), extraEdge.getFlags(), extraEdge.getName(), extraEdge.fetchWayGeometry(3))); } this.walkOnly = walkOnly; this.walkSpeedKmH = walkSpeedKmh; }
@Test public void testExtract2() { Graph g = createGraph(); g.edge(1, 2, 10, false); g.edge(2, 3, 20, false); EdgeExplorer explorer = g.createEdgeExplorer(carOutEdges); EdgeIterator iter = explorer.setBaseNode(1); iter.next(); PathBidirRef pw = new PathBidirRef(g, new FastestWeighting(carEncoder)); pw.sptEntry = new SPTEntry(iter.getEdge(), 2, 10); pw.sptEntry.parent = new SPTEntry(EdgeIterator.NO_EDGE, 1, 0); explorer = g.createEdgeExplorer(DefaultEdgeFilter.inEdges(carEncoder)); iter = explorer.setBaseNode(3); iter.next(); pw.edgeTo = new SPTEntry(iter.getEdge(), 2, 20); pw.edgeTo.parent = new SPTEntry(EdgeIterator.NO_EDGE, 3, 0); Path p = pw.extract(); assertEquals(IntArrayList.from(new int[]{1, 2, 3}), p.calcNodes()); assertEquals(30, p.getDistance(), 1e-4); } }
/** * This method removes networks that will be never be visited by this filter. See #235 for * example, small areas like parking lots are sometimes connected to the whole network through a * one-way road. This is clearly an error - but is causes the routing to fail when a point gets * connected to this small area. This routine removes all these networks from the graph. * <p> * * @return number of removed edges */ int removeDeadEndUnvisitedNetworks(final PrepEdgeFilter bothFilter) { StopWatch sw = new StopWatch(bothFilter.getEncoder() + " findComponents").start(); final EdgeFilter outFilter = DefaultEdgeFilter.outEdges(bothFilter.getEncoder()); // partition graph into strongly connected components using Tarjan's algorithm TarjansSCCAlgorithm tarjan = new TarjansSCCAlgorithm(ghStorage, outFilter, true); List<IntArrayList> components = tarjan.findComponents(); logger.info(sw.stop() + ", size:" + components.size()); return removeEdges(bothFilter, components, minOneWayNetworkSize); }
public InstructionsFromEdges(int tmpNode, Graph graph, Weighting weighting, FlagEncoder encoder, NodeAccess nodeAccess, Translation tr, InstructionList ways) { this.weighting = weighting; this.encoder = encoder; this.nodeAccess = nodeAccess; this.tr = tr; this.ways = ways; prevLat = this.nodeAccess.getLatitude(tmpNode); prevLon = this.nodeAccess.getLongitude(tmpNode); prevNode = -1; prevInRoundabout = false; prevName = null; outEdgeExplorer = graph.createEdgeExplorer(DefaultEdgeFilter.outEdges(encoder)); crossingExplorer = graph.createEdgeExplorer(DefaultEdgeFilter.allEdges(encoder)); }
@Override public EdgeExplorer createEdgeExplorer(final EdgeFilter edgeFilter) { if (!isInitialized()) throw new IllegalStateException("Call lookup before using this graph"); if (useEdgeExplorerCache) { int counter = -1; if (edgeFilter instanceof DefaultEdgeFilter) { DefaultEdgeFilter dee = (DefaultEdgeFilter) edgeFilter; counter = 0; if (dee.acceptsBackward()) counter = 1; if (dee.acceptsForward()) counter += 2; if (counter == 0) throw new IllegalStateException("You tried to use an edge filter blocking every access"); } else if (edgeFilter == EdgeFilter.ALL_EDGES) { counter = 4; } if (counter >= 0) { EdgeExplorer cached = cacheMap.get(counter); if (cached == null) { cached = createUncachedEdgeExplorer(edgeFilter); cacheMap.put(counter, cached); } return cached; } } return createUncachedEdgeExplorer(edgeFilter); }
public static DefaultEdgeFilter inEdges(FlagEncoder flagEncoder) { return new DefaultEdgeFilter(flagEncoder, false, true); }
@Override public void initFromGraph() { super.initFromGraph(); ignoreNodeFilter = new IgnoreNodeFilter(prepareGraph, maxLevel); final EdgeFilter allFilter = DefaultEdgeFilter.allEdges(encoder); final EdgeFilter remainingNodesFilter = new LevelEdgeFilter(prepareGraph) { @Override public final boolean accept(EdgeIteratorState edgeState) { return super.accept(edgeState) && allFilter.accept(edgeState); } }; remainingEdgeExplorer = prepareGraph.createEdgeExplorer(remainingNodesFilter); prepareAlgo = new DijkstraOneToMany(prepareGraph, prepareWeighting, TraversalMode.NODE_BASED); }
@Override public void initFromGraph() { inEdgeExplorer = prepareGraph.createEdgeExplorer(DefaultEdgeFilter.inEdges(encoder)); outEdgeExplorer = prepareGraph.createEdgeExplorer(DefaultEdgeFilter.outEdges(encoder)); maxLevel = prepareGraph.getNodes(); maxEdgesCount = prepareGraph.getOriginalEdges(); }
@Test public void testTarjan() { GraphHopperStorage g = createSubnetworkTestStorage(); // Requires a single vehicle type, otherwise we throw. final EdgeFilter filter = DefaultEdgeFilter.outEdges(carFlagEncoder); TarjansSCCAlgorithm tarjan = new TarjansSCCAlgorithm(g, filter, false); List<IntArrayList> components = tarjan.findComponents(); assertEquals(4, components.size()); assertEquals(IntArrayList.from(13, 5, 3, 7, 0), components.get(0)); assertEquals(IntArrayList.from(2, 4, 12, 11, 8, 1), components.get(1)); assertEquals(IntArrayList.from(10, 14, 6), components.get(2)); assertEquals(IntArrayList.from(15, 9), components.get(3)); }
@Override public EdgeExplorer createEdgeExplorer(final EdgeFilter edgeFilter) { if (!isInitialized()) throw new IllegalStateException("Call lookup before using this graph"); if (useEdgeExplorerCache) { int counter = -1; if (edgeFilter instanceof DefaultEdgeFilter) { DefaultEdgeFilter dee = (DefaultEdgeFilter) edgeFilter; counter = 0; if (dee.acceptsBackward()) counter = 1; if (dee.acceptsForward()) counter += 2; if (counter == 0) throw new IllegalStateException("You tried to use an edge filter blocking every access"); } else if (edgeFilter == EdgeFilter.ALL_EDGES) { counter = 4; } if (counter >= 0) { EdgeExplorer cached = cacheMap.get(counter); if (cached == null) { cached = createUncachedEdgeExplorer(edgeFilter); cacheMap.put(counter, cached); } return cached; } } return createUncachedEdgeExplorer(edgeFilter); }
public static DefaultEdgeFilter outEdges(FlagEncoder flagEncoder) { return new DefaultEdgeFilter(flagEncoder, true, false); }
@Override public List<QueryResult> lookup(List<GHPoint> points, FlagEncoder encoder) { if (points.size() != 1 || ghRequest.getPoints().size() != 1) throw new IllegalArgumentException("For round trip calculation exactly one point is required"); final double distanceInMeter = ghRequest.getHints().getDouble(RoundTrip.DISTANCE, 10000); final long seed = ghRequest.getHints().getLong(RoundTrip.SEED, 0L); double initialHeading = ghRequest.getFavoredHeading(0); final int roundTripPointCount = Math.min(20, ghRequest.getHints().getInt(RoundTrip.POINTS, 2 + (int) (distanceInMeter / 50000))); final GHPoint start = points.get(0); TourStrategy strategy = new MultiPointTour(new Random(seed), distanceInMeter, roundTripPointCount, initialHeading); queryResults = new ArrayList<>(2 + strategy.getNumberOfGeneratedPoints()); EdgeFilter edgeFilter = DefaultEdgeFilter.allEdges(encoder); QueryResult startQR = locationIndex.findClosest(start.lat, start.lon, edgeFilter); if (!startQR.isValid()) throw new PointNotFoundException("Cannot find point 0: " + start, 0); queryResults.add(startQR); GHPoint last = start; for (int i = 0; i < strategy.getNumberOfGeneratedPoints(); i++) { double heading = strategy.getHeadingForIteration(i); QueryResult result = generateValidPoint(last, strategy.getDistanceForIteration(i), heading, edgeFilter); if (result == null) { ghResponse.addError(new IllegalStateException("Could not find a valid point after " + maxRetries + " tries, for the point:" + last)); return Collections.emptyList(); } last = result.getSnappedPoint(); queryResults.add(result); } queryResults.add(startQR); return queryResults; }
/** * @param graph specifies the graph where this algorithm will run on * @param weighting set the used weight calculation (e.g. fastest, shortest). * @param traversalMode how the graph is traversed e.g. if via nodes or edges. */ public AbstractRoutingAlgorithm(Graph graph, Weighting weighting, TraversalMode traversalMode) { this.weighting = weighting; this.flagEncoder = weighting.getFlagEncoder(); this.traversalMode = traversalMode; this.graph = graph; this.nodeAccess = graph.getNodeAccess(); outEdgeExplorer = graph.createEdgeExplorer(DefaultEdgeFilter.outEdges(flagEncoder)); inEdgeExplorer = graph.createEdgeExplorer(DefaultEdgeFilter.inEdges(flagEncoder)); }
EdgeFilter outFilter = DefaultEdgeFilter.outEdges(encoder); final EdgeExplorer outExplorer = graph.createEdgeExplorer(outFilter); MiniPerfTest miniPerf = new MiniPerfTest() {