Examples with EdgeFilter com.graphhopper.routing.util.EdgeFilter used on opensource projects

Example 1 with EdgeFilter

use of com.graphhopper.routing.util.EdgeFilter in project graphhopper by graphhopper.

the class ChangeGraphHelper method applyChange.

private long applyChange(JsonFeature jsonFeature, FlagEncoder encoder) {
    long updates = 0;
    EdgeFilter filter = new DefaultEdgeFilter(encoder);
    GHIntHashSet edges = new GHIntHashSet();
    if (jsonFeature.hasGeometry()) {
        graphBrowser.fillEdgeIDs(edges, jsonFeature.getGeometry(), filter);
    } else if (jsonFeature.getBBox() != null) {
        graphBrowser.findEdgesInShape(edges, jsonFeature.getBBox(), filter);
    } else
        throw new IllegalArgumentException("Feature " + jsonFeature.getId() + " has no geometry and no bbox");
    Iterator<IntCursor> iter = edges.iterator();
    Map<String, Object> props = jsonFeature.getProperties();
    while (iter.hasNext()) {
        int edgeId = iter.next().value;
        EdgeIteratorState edge = graph.getEdgeIteratorState(edgeId, Integer.MIN_VALUE);
        if (props.containsKey("access")) {
            boolean value = (boolean) props.get("access");
            updates++;
            if (enableLogging)
                logger.info(encoder.toString() + " - access change via feature " + jsonFeature.getId());
            edge.setFlags(encoder.setAccess(edge.getFlags(), value, value));
        } else if (props.containsKey("speed")) {
            // TODO use different speed for the different directions (see e.g. Bike2WeightFlagEncoder)
            double value = ((Number) props.get("speed")).doubleValue();
            double oldSpeed = encoder.getSpeed(edge.getFlags());
            if (oldSpeed != value) {
                updates++;
                if (enableLogging)
                    logger.info(encoder.toString() + " - speed change via feature " + jsonFeature.getId() + ". Old: " + oldSpeed + ", new:" + value);
                edge.setFlags(encoder.setSpeed(edge.getFlags(), value));
            }
        }
    }
    return updates;
}

Example 2 with EdgeFilter

use of com.graphhopper.routing.util.EdgeFilter in project graphhopper by graphhopper.

the class RealtimeFeed method fromProtobuf.

public static RealtimeFeed fromProtobuf(Graph graph, GtfsStorage staticGtfs, PtFlagEncoder encoder, GtfsRealtime.FeedMessage feedMessage) {
    String feedKey = "gtfs_0";
    GTFSFeed feed = staticGtfs.getGtfsFeeds().get(feedKey);
    // TODO: Require configuration of feed and agency this realtime feed is for.
    // Realtime feeds are always specific to an agency.
    Agency agency = feed.agency.values().iterator().next();
    final IntHashSet blockedEdges = new IntHashSet();
    final IntLongHashMap delaysForBoardEdges = new IntLongHashMap();
    final IntLongHashMap delaysForAlightEdges = new IntLongHashMap();
    final LinkedList<VirtualEdgeIteratorState> additionalEdges = new LinkedList<>();
    final Graph overlayGraph = new Graph() {

        int nNodes = 0;

        int firstEdge = graph.getAllEdges().getMaxId() + 1;

        final NodeAccess nodeAccess = new NodeAccess() {

            IntIntHashMap additionalNodeFields = new IntIntHashMap();

            @Override
            public int getAdditionalNodeField(int nodeId) {
                return 0;
            }

            @Override
            public void setAdditionalNodeField(int nodeId, int additionalValue) {
                additionalNodeFields.put(nodeId, additionalValue);
            }

            @Override
            public boolean is3D() {
                return false;
            }

            @Override
            public int getDimension() {
                return 0;
            }

            @Override
            public void ensureNode(int nodeId) {
            }

            @Override
            public void setNode(int nodeId, double lat, double lon) {
            }

            @Override
            public void setNode(int nodeId, double lat, double lon, double ele) {
            }

            @Override
            public double getLatitude(int nodeId) {
                return 0;
            }

            @Override
            public double getLat(int nodeId) {
                return 0;
            }

            @Override
            public double getLongitude(int nodeId) {
                return 0;
            }

            @Override
            public double getLon(int nodeId) {
                return 0;
            }

            @Override
            public double getElevation(int nodeId) {
                return 0;
            }

            @Override
            public double getEle(int nodeId) {
                return 0;
            }
        };

        @Override
        public Graph getBaseGraph() {
            return graph;
        }

        @Override
        public int getNodes() {
            return graph.getNodes() + nNodes;
        }

        @Override
        public NodeAccess getNodeAccess() {
            return nodeAccess;
        }

        @Override
        public BBox getBounds() {
            return null;
        }

        @Override
        public EdgeIteratorState edge(int a, int b) {
            return null;
        }

        @Override
        public EdgeIteratorState edge(int a, int b, double distance, boolean bothDirections) {
            int edge = firstEdge++;
            final VirtualEdgeIteratorState newEdge = new VirtualEdgeIteratorState(-1, edge, a, b, distance, 0, "", new PointList());
            final VirtualEdgeIteratorState reverseNewEdge = new VirtualEdgeIteratorState(-1, edge, b, a, distance, 0, "", new PointList());
            newEdge.setReverseEdge(reverseNewEdge);
            reverseNewEdge.setReverseEdge(newEdge);
            additionalEdges.push(newEdge);
            return newEdge;
        }

        @Override
        public EdgeIteratorState getEdgeIteratorState(int edgeId, int adjNode) {
            return null;
        }

        @Override
        public AllEdgesIterator getAllEdges() {
            return null;
        }

        @Override
        public EdgeExplorer createEdgeExplorer(EdgeFilter filter) {
            return null;
        }

        @Override
        public EdgeExplorer createEdgeExplorer() {
            return graph.createEdgeExplorer();
        }

        @Override
        public Graph copyTo(Graph g) {
            return null;
        }

        @Override
        public GraphExtension getExtension() {
            throw new RuntimeException();
        }
    };
    Map<Integer, String> routes = new HashMap<>();
    Map<GtfsStorage.Validity, Integer> operatingDayPatterns = new HashMap<>(staticGtfs.getOperatingDayPatterns());
    Map<Integer, byte[]> tripDescriptors = new HashMap<>();
    Map<Integer, Integer> stopSequences = new HashMap<>();
    Map<String, int[]> boardEdgesForTrip = new HashMap<>();
    Map<String, int[]> alightEdgesForTrip = new HashMap<>();
    Map<GtfsStorage.FeedIdWithTimezone, Integer> writableTimeZones = new HashMap<>();
    GtfsStorageI gtfsStorage = new GtfsStorageI() {

        @Override
        public Map<String, Fare> getFares() {
            return null;
        }

        @Override
        public Map<GtfsStorage.Validity, Integer> getOperatingDayPatterns() {
            return operatingDayPatterns;
        }

        @Override
        public Map<GtfsStorage.FeedIdWithTimezone, Integer> getWritableTimeZones() {
            return writableTimeZones;
        }

        @Override
        public Map<Integer, byte[]> getTripDescriptors() {
            return tripDescriptors;
        }

        @Override
        public Map<Integer, Integer> getStopSequences() {
            return stopSequences;
        }

        @Override
        public Map<String, int[]> getBoardEdgesForTrip() {
            return boardEdgesForTrip;
        }

        @Override
        public Map<String, int[]> getAlightEdgesForTrip() {
            return alightEdgesForTrip;
        }

        @Override
        public Map<String, GTFSFeed> getGtfsFeeds() {
            HashMap<String, GTFSFeed> stringGTFSFeedHashMap = new HashMap<>();
            stringGTFSFeedHashMap.put(feedKey, feed);
            return stringGTFSFeedHashMap;
        }

        @Override
        public Map<String, Transfers> getTransfers() {
            return staticGtfs.getTransfers();
        }

        @Override
        public Map<String, Integer> getStationNodes() {
            return staticGtfs.getStationNodes();
        }

        @Override
        public Map<Integer, String> getRoutes() {
            return routes;
        }
    };
    final GtfsReader gtfsReader = new GtfsReader(feedKey, overlayGraph, gtfsStorage, encoder, null);
    Instant timestamp = Instant.ofEpochSecond(feedMessage.getHeader().getTimestamp());
    // FIXME
    LocalDate dateToChange = timestamp.atZone(ZoneId.of(agency.agency_timezone)).toLocalDate();
    BitSet validOnDay = new BitSet();
    LocalDate startDate = feed.calculateStats().getStartDate();
    validOnDay.set((int) DAYS.between(startDate, dateToChange));
    feedMessage.getEntityList().stream().filter(GtfsRealtime.FeedEntity::hasTripUpdate).map(GtfsRealtime.FeedEntity::getTripUpdate).filter(tripUpdate -> tripUpdate.getTrip().getScheduleRelationship() == GtfsRealtime.TripDescriptor.ScheduleRelationship.SCHEDULED).forEach(tripUpdate -> {
        String key = GtfsStorage.tripKey(tripUpdate.getTrip().getTripId(), tripUpdate.getTrip().getStartTime());
        final int[] boardEdges = staticGtfs.getBoardEdgesForTrip().get(key);
        final int[] leaveEdges = staticGtfs.getAlightEdgesForTrip().get(key);
        if (boardEdges == null || leaveEdges == null) {
            logger.warn("Trip not found: {}", tripUpdate.getTrip());
            return;
        }
        tripUpdate.getStopTimeUpdateList().stream().filter(stopTimeUpdate -> stopTimeUpdate.getScheduleRelationship() == SKIPPED).mapToInt(GtfsRealtime.TripUpdate.StopTimeUpdate::getStopSequence).forEach(skippedStopSequenceNumber -> {
            blockedEdges.add(boardEdges[skippedStopSequenceNumber]);
            blockedEdges.add(leaveEdges[skippedStopSequenceNumber]);
        });
        GtfsReader.TripWithStopTimes tripWithStopTimes = toTripWithStopTimes(feed, agency, tripUpdate);
        tripWithStopTimes.stopTimes.forEach(stopTime -> {
            if (stopTime.stop_sequence > leaveEdges.length - 1) {
                logger.warn("Stop sequence number too high {} vs {}", stopTime.stop_sequence, leaveEdges.length);
                return;
            }
            final StopTime originalStopTime = feed.stop_times.get(new Fun.Tuple2(tripUpdate.getTrip().getTripId(), stopTime.stop_sequence));
            int arrivalDelay = stopTime.arrival_time - originalStopTime.arrival_time;
            delaysForAlightEdges.put(leaveEdges[stopTime.stop_sequence], arrivalDelay * 1000);
            int departureDelay = stopTime.departure_time - originalStopTime.departure_time;
            if (departureDelay > 0) {
                int boardEdge = boardEdges[stopTime.stop_sequence];
                int departureNode = graph.getEdgeIteratorState(boardEdge, Integer.MIN_VALUE).getAdjNode();
                int timeOffset = tripUpdate.getTrip().hasStartTime() ? LocalTime.parse(tripUpdate.getTrip().getStartTime()).toSecondOfDay() : 0;
                int delayedBoardEdge = gtfsReader.addDelayedBoardEdge(ZoneId.of(agency.agency_timezone), tripUpdate.getTrip(), stopTime.stop_sequence, stopTime.departure_time + timeOffset, departureNode, validOnDay);
                delaysForBoardEdges.put(delayedBoardEdge, departureDelay * 1000);
            }
        });
    });
    feedMessage.getEntityList().stream().filter(GtfsRealtime.FeedEntity::hasTripUpdate).map(GtfsRealtime.FeedEntity::getTripUpdate).filter(tripUpdate -> tripUpdate.getTrip().getScheduleRelationship() == GtfsRealtime.TripDescriptor.ScheduleRelationship.ADDED).forEach(tripUpdate -> {
        Trip trip = new Trip();
        trip.trip_id = tripUpdate.getTrip().getTripId();
        trip.route_id = tripUpdate.getTrip().getRouteId();
        final List<StopTime> stopTimes = tripUpdate.getStopTimeUpdateList().stream().map(stopTimeUpdate -> {
            final StopTime stopTime = new StopTime();
            stopTime.stop_sequence = stopTimeUpdate.getStopSequence();
            stopTime.stop_id = stopTimeUpdate.getStopId();
            stopTime.trip_id = trip.trip_id;
            final ZonedDateTime arrival_time = Instant.ofEpochSecond(stopTimeUpdate.getArrival().getTime()).atZone(ZoneId.of(agency.agency_timezone));
            stopTime.arrival_time = (int) Duration.between(arrival_time.truncatedTo(ChronoUnit.DAYS), arrival_time).getSeconds();
            final ZonedDateTime departure_time = Instant.ofEpochSecond(stopTimeUpdate.getArrival().getTime()).atZone(ZoneId.of(agency.agency_timezone));
            stopTime.departure_time = (int) Duration.between(departure_time.truncatedTo(ChronoUnit.DAYS), departure_time).getSeconds();
            return stopTime;
        }).collect(Collectors.toList());
        GtfsReader.TripWithStopTimes tripWithStopTimes = new GtfsReader.TripWithStopTimes(trip, stopTimes, validOnDay, Collections.emptySet(), Collections.emptySet());
        gtfsReader.addTrip(ZoneId.of(agency.agency_timezone), 0, new ArrayList<>(), tripWithStopTimes, tripUpdate.getTrip());
    });
    gtfsReader.wireUpStops();
    return new RealtimeFeed(staticGtfs, feed, agency, feedMessage, blockedEdges, delaysForBoardEdges, delaysForAlightEdges, additionalEdges, tripDescriptors, stopSequences, operatingDayPatterns);
}

Example 3 with EdgeFilter

use of com.graphhopper.routing.util.EdgeFilter in project graphhopper by graphhopper.

the class PrepareRoutingSubnetworks method removeDeadEndUnvisitedNetworks.

/**
 * 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 = new DefaultEdgeFilter(bothFilter.getEncoder(), false, true);
    // 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);
}

Example 4 with EdgeFilter

use of com.graphhopper.routing.util.EdgeFilter in project graphhopper by graphhopper.

the class GtfsReader method connectStopsToStreetNetwork.

void connectStopsToStreetNetwork() {
    EncodingManager em = graph.getEncodingManager();
    FlagEncoder footEncoder = em.getEncoder("foot");
    final EdgeFilter filter = new DefaultSnapFilter(new FastestWeighting(footEncoder), em.getBooleanEncodedValue(Subnetwork.key("foot")));
    for (Stop stop : feed.stops.values()) {
        if (stop.location_type == 0) {
            // Only stops. Not interested in parent stations for now.
            Snap locationSnap = walkNetworkIndex.findClosest(stop.stop_lat, stop.stop_lon, filter);
            Integer stopNode;
            if (locationSnap.isValid()) {
                stopNode = gtfsStorage.getStreetToPt().get(locationSnap.getClosestNode());
                if (stopNode == null) {
                    stopNode = out.createNode();
                    indexBuilder.addToAllTilesOnLine(stopNode, stop.stop_lat, stop.stop_lon, stop.stop_lat, stop.stop_lon);
                    gtfsStorage.getPtToStreet().put(stopNode, locationSnap.getClosestNode());
                    gtfsStorage.getStreetToPt().put(locationSnap.getClosestNode(), stopNode);
                }
            } else {
                stopNode = out.createNode();
                indexBuilder.addToAllTilesOnLine(stopNode, stop.stop_lat, stop.stop_lon, stop.stop_lat, stop.stop_lon);
            }
            gtfsStorage.getStationNodes().put(new GtfsStorage.FeedIdWithStopId(id, stop.stop_id), stopNode);
        }
    }
}

Example 5 with EdgeFilter

use of com.graphhopper.routing.util.EdgeFilter in project graphhopper by graphhopper.

the class CHEdgeIteratorTest method testUpdateFlags.

@Test
public void testUpdateFlags() {
    CarFlagEncoder carFlagEncoder = new CarFlagEncoder();
    EncodingManager encodingManager = new EncodingManager(carFlagEncoder);
    FastestWeighting weighting = new FastestWeighting(carFlagEncoder);
    EdgeFilter carOutFilter = new DefaultEdgeFilter(carFlagEncoder, false, true);
    GraphHopperStorage ghStorage = new GraphBuilder(encodingManager).setCHGraph(weighting).create();
    CHGraph g = ghStorage.getGraph(CHGraph.class, weighting);
    g.edge(0, 1).setDistance(12).setFlags(carFlagEncoder.setProperties(10, true, true));
    g.edge(0, 2).setDistance(13).setFlags(carFlagEncoder.setProperties(20, true, true));
    ghStorage.freeze();
    assertEquals(2, GHUtility.count(g.getAllEdges()));
    assertEquals(1, GHUtility.count(g.createEdgeExplorer(carOutFilter).setBaseNode(1)));
    EdgeIteratorState iter = GHUtility.getEdge(g, 0, 1);
    assertEquals(1, iter.getAdjNode());
    assertEquals(carFlagEncoder.setProperties(10, true, true), iter.getFlags());
    // update setProperties
    iter.setFlags(carFlagEncoder.setProperties(20, true, false));
    assertEquals(12, iter.getDistance(), 1e-4);
    // update distance
    iter.setDistance(10);
    assertEquals(10, iter.getDistance(), 1e-4);
    assertEquals(0, GHUtility.count(g.createEdgeExplorer(carOutFilter).setBaseNode(1)));
    iter = GHUtility.getEdge(g, 0, 1);
    assertEquals(carFlagEncoder.setProperties(20, true, false), iter.getFlags());
    assertEquals(10, iter.getDistance(), 1e-4);
    assertEquals(1, GHUtility.getNeighbors(g.createEdgeExplorer().setBaseNode(1)).size());
    assertEquals(0, GHUtility.getNeighbors(g.createEdgeExplorer(carOutFilter).setBaseNode(1)).size());
}