public final boolean isForward(EdgeIteratorState edge, int accessType) { // TODO shift dependent on the accessType // use only one bit for foot? long flags = edge.getFlags(); return (flags & (isBit0Empty(flags) ? forwardBit : backwardBit)) != 0; }
private boolean isValidOn(EdgeIteratorState edge, long instant) { GtfsStorage.EdgeType edgeType = flagEncoder.getEdgeType(edge.getFlags()); if (edgeType == GtfsStorage.EdgeType.BOARD || edgeType == GtfsStorage.EdgeType.ALIGHT) { final int validityId = flagEncoder.getValidityId(edge.getFlags()); final GtfsStorage.Validity validity = realtimeFeed.getValidity(validityId); final int trafficDay = (int) ChronoUnit.DAYS.between(validity.start, Instant.ofEpochMilli(instant).atZone(validity.zoneId).toLocalDate()); return trafficDay >= 0 && validity.validity.get(trafficDay); } else { return true; } }
@Override public double calcWeight(EdgeIteratorState edgeState, boolean reverse, int prevOrNextEdgeId) { double weight = super.calcWeight(edgeState, reverse, prevOrNextEdgeId); if (Double.isInfinite(weight)) return Double.POSITIVE_INFINITY; return weight / (0.5 + flagEncoder.getDouble(edgeState.getFlags(), KEY)); } }
@Override public double calcWeight(EdgeIteratorState edge, boolean reverse, int prevOrNextEdgeId) { double priority = flagEncoder.getDouble(edge.getFlags(), KEY); double bendiness = flagEncoder.getDouble(edge.getFlags(), MotorcycleFlagEncoder.CURVATURE_KEY); double speed = getRoadSpeed(edge, reverse); double roadDistance = edge.getDistance(); // We use the log of the speed to decrease the impact of the speed, therefore we don't use the highway double regularWeight = roadDistance / Math.log(speed); return (bendiness * regularWeight) / (0.5 + priority); }
private long waitingTime(EdgeIteratorState edge, long earliestStartTime) { long l = flagEncoder.getTime(edge.getFlags()) * 1000 - millisOnTravelDay(edge, earliestStartTime); if (!reverse) { if (l < 0) l = l + 24*60*60*1000; } else { if (l > 0) l = l - 24*60*60*1000; } return l; }
@Override public double calcWeight(EdgeIteratorState edge, boolean reverse, int prevOrNextEdgeId) { double speed = reverse ? flagEncoder.getReverseSpeed(edge.getFlags()) : flagEncoder.getSpeed(edge.getFlags()); if (speed == 0) return Double.POSITIVE_INFINITY; double time = edge.getDistance() / speed * SPEED_CONV; // add direction penalties at start/stop/via points boolean unfavoredEdge = edge.getBool(EdgeIteratorState.K_UNFAVORED_EDGE, false); if (unfavoredEdge) time += headingPenalty; return time; }
private double getSpeed(EdgeIteratorState edge) { if (encoder instanceof DataFlagEncoder) { return ((DataFlagEncoder) encoder).getMaxspeed(edge, 0, false); } else { return encoder.getSpeed(edge.getFlags()); } }
private long millisOnTravelDay(EdgeIteratorState edge, long instant) { final ZoneId zoneId = gtfsStorage.getTimeZones().get(flagEncoder.getValidityId(edge.getFlags())).zoneId; return Instant.ofEpochMilli(instant).atZone(zoneId).toLocalTime().toNanoOfDay() / 1000000L; }
private void setFeedIdWithTimezone(EdgeIteratorState leaveTimeExpandedNetworkEdge, GtfsStorage.FeedIdWithTimezone validOn) { int validityId; if (gtfsStorage.getWritableTimeZones().containsKey(validOn)) { validityId = gtfsStorage.getWritableTimeZones().get(validOn); } else { validityId = gtfsStorage.getWritableTimeZones().size(); gtfsStorage.getWritableTimeZones().put(validOn, validityId); } leaveTimeExpandedNetworkEdge.setFlags(encoder.setValidityId(leaveTimeExpandedNetworkEdge.getFlags(), validityId)); }
@Override public void applyWayTags(ReaderWay way, EdgeIteratorState edge) { double speed = this.getSpeed(edge.getFlags()); double roadDistance = edge.getDistance(); double beelineDistance = getBeelineDistance(way); double bendiness = beelineDistance / roadDistance; bendiness = discriminateSlowStreets(bendiness, speed); bendiness = increaseBendinessImpact(bendiness); bendiness = correctErrors(bendiness); edge.setFlags(this.curvatureEncoder.setValue(edge.getFlags(), convertToInt(bendiness))); }
private void patchArrivalTimeline(ZoneId zoneId, NavigableMap<Integer, Integer> timeline, int platformExitNode) { timeline.forEach((time, node) -> { EdgeIteratorState edge = graph.edge(node, platformExitNode); edge.setFlags(encoder.setAccess(edge.getFlags(), true, false)); setEdgeTypeAndClearDistance(edge, GtfsStorage.EdgeType.LEAVE_TIME_EXPANDED_NETWORK); edge.setFlags(encoder.setTime(edge.getFlags(), time)); setFeedIdWithTimezone(edge, new GtfsStorage.FeedIdWithTimezone(id, zoneId)); }); }
public void setRoundabout(boolean clockwise) { for (FlagEncoder encoder : mixedEncoders.fetchEdgeEncoders()) { for (EdgeIteratorState edge : roundaboutEdges) { edge.setFlags(encoder.setAccess(edge.getFlags(), clockwise, !clockwise)); edge.setFlags(encoder.setBool(edge.getFlags(), FlagEncoder.K_ROUNDABOUT, true)); } } this.clockwise = clockwise; }
@Test public void testUnchangedForStepsBridgeAndTunnel() { Graph graph = initExampleGraph(); EdgeIteratorState edge = GHUtility.getEdge(graph, 0, 1); long oldFlags = edge.getFlags(); ReaderWay way = new ReaderWay(1); way.setTag("highway", "steps"); encoder.applyWayTags(way, edge); assertEquals(oldFlags, edge.getFlags()); }
public void inverse3to9() { for (FlagEncoder encoder : mixedEncoders.fetchEdgeEncoders()) { long flags = edge3to9.getFlags(); edge3to9.setFlags(encoder.setAccess(flags, !edge3to9.isForward(encoder), false)); } }
public void inverse3to6() { for (FlagEncoder encoder : mixedEncoders.fetchEdgeEncoders()) { long flags = edge3to6.getFlags(); edge3to6.setFlags(encoder.setAccess(flags, !edge3to6.isForward(encoder), true)); } }
@Test public void testFord() { ReaderWay osmWay = new ReaderWay(0); osmWay.setTag("highway", "unclassified"); osmWay.setTag("ford", "yes"); long flags = encoder.handleWayTags(osmWay, 1, 0); EdgeIteratorState edge = GHUtility.createMockedEdgeIteratorState(0, flags); assertEquals("ford", encoder.getTransportModeAsString(edge)); assertTrue(encoder.isTransportModeFord(edge.getFlags())); assertTrue(encoder.getAnnotation(edge.getFlags(), TranslationMapTest.SINGLETON.get("en")).getMessage().contains("ford")); }
@Test public void testPropertiesWithNoInit() { graph = createGHStorage(); assertEquals(0, graph.edge(0, 1).getFlags()); assertEquals(0, graph.edge(0, 2).getDistance(), 1e-6); }
@Test public void testApplyWayTags() { Graph graph = initExampleGraph(); EdgeIteratorState edge = GHUtility.getEdge(graph, 0, 1); ReaderWay way = new ReaderWay(1); encoder.applyWayTags(way, edge); long flags = edge.getFlags(); // decrease speed assertEquals(2, encoder.getSpeed(flags), 1e-1); // increase speed but use maximum speed (calculated was 24) assertEquals(18, encoder.getReverseSpeed(flags), 1e-1); }