@Override public long handleWayTags(ReaderWay way, long allowed, long relationFlags) { if (!isAccept(allowed)) return 0; long flags = 0; double wayTypeSpeed = getSpeed(way); if (!isFerry(allowed)) { wayTypeSpeed = applyMaxSpeed(way, wayTypeSpeed); flags = handleSpeed(way, wayTypeSpeed, flags); flags = handleBikeRelated(way, flags, relationFlags > UNCHANGED.getValue()); boolean isRoundabout = way.hasTag("junction", "roundabout") || way.hasTag("junction", "circular"); if (isRoundabout) { flags = setBool(flags, K_ROUNDABOUT, true); } } else { double ferrySpeed = getFerrySpeed(way); flags = handleSpeed(way, ferrySpeed, flags); flags |= directionBitMask; } int priorityFromRelation = 0; if (relationFlags != 0) priorityFromRelation = (int) relationCodeEncoder.getValue(relationFlags); flags = priorityWayEncoder.setValue(flags, handlePriority(way, wayTypeSpeed, priorityFromRelation)); return flags; }
long relFlags = encoder.handleRelationTags(osmRel, 0); long flags = encoder.handleWayTags(osmWay, allowed, relFlags); assertEquals(18, encoder.getSpeed(flags), 1e-1); assertPriority(PriorityCode.PREFER.getValue(), osmWay); assertEquals("small way, unpaved", getWayTypeFromFlags(osmWay)); relFlags = encoder.handleRelationTags(osmRel, 0); flags = encoder.handleWayTags(osmWay, allowed, relFlags); assertEquals(18, encoder.getSpeed(flags), 1e-1); assertPriority(PriorityCode.PREFER.getValue(), osmWay); assertEquals("small way, unpaved", getWayTypeFromFlags(osmWay)); relFlags = encoder.handleRelationTags(osmRel, 0); flags = encoder.handleWayTags(osmWay, allowed, relFlags); assertPriority(PriorityCode.PREFER.getValue(), osmWay); assertEquals(18, encoder.getSpeed(flags), 1e-1); relFlags = encoder.handleRelationTags(osmRel, 0); flags = encoder.handleWayTags(osmWay, allowed, relFlags); assertPriority(PriorityCode.PREFER.getValue(), osmWay); assertEquals(18, encoder.getSpeed(flags), 1e-1); relFlags = encoder.handleRelationTags(osmRel, 0); flags = encoder.handleWayTags(osmWay, allowed, relFlags); assertEquals(18, encoder.getSpeed(flags), 1e-1); assertPriority(PriorityCode.PREFER.getValue(), osmWay); assertEquals("", getWayTypeFromFlags(osmWay));
@Override public InstructionAnnotation getAnnotation(long flags, Translation tr) { int paveType = 0; // paved if (isBool(flags, K_UNPAVED)) paveType = 1; // unpaved int wayType = (int) wayTypeEncoder.getValue(flags); String wayName = getWayName(paveType, wayType, tr); return new InstructionAnnotation(0, wayName); }
protected double getSpeedFromFlags(ReaderWay way) { long allowed = encoder.acceptBit; long flags = encoder.handleWayTags(way, allowed, 0); return encoder.getSpeed(flags); }
@Test public void testPreferenceForSlowSpeed() { ReaderWay osmWay = new ReaderWay(1); osmWay.setTag("highway", "tertiary"); assertEquals(30, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(osmWay, 49))), 1e-1); assertPriority(PREFER.getValue(), osmWay); }
@Test public void testMaxSpeed() { ReaderWay way = new ReaderWay(1); way.setTag("highway", "secondary"); way.setTag("maxspeed", "10"); long allowed = encoder.acceptWay(way); long encoded = encoder.handleWayTags(way, allowed, 0); assertEquals(10, encoder.getSpeed(encoded), 1e-1); assertPriority(VERY_NICE.getValue(), way); way = new ReaderWay(1); way.setTag("highway", "tertiary"); way.setTag("maxspeed", "90"); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(way, 20))), 1e-1); assertPriority(UNCHANGED.getValue(), way); way = new ReaderWay(1); way.setTag("highway", "track"); way.setTag("maxspeed", "90"); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(way, 20))), 1e-1); assertPriority(UNCHANGED.getValue(), way); way = new ReaderWay(1); way.setTag("highway", "residential"); way.setTag("maxspeed", "15"); assertEquals(15, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(way, 15))), 1.0); allowed = encoder.acceptWay(way); encoded = encoder.handleWayTags(way, allowed, 0); assertEquals(15, encoder.getSpeed(encoded), 1.0); assertPriority(VERY_NICE.getValue(), way); }
@Test public void testSetSpeed0_issue367() { long flags = encoder.setProperties(10, true, true); flags = encoder.setSpeed(flags, 0); assertEquals(0, encoder.getSpeed(flags), .1); assertEquals(10, encoder.getReverseSpeed(flags), .1); assertFalse(encoder.isForward(flags)); assertTrue(encoder.isBackward(flags)); }
double maxSpeed = getMaxSpeed(way); if (preferHighwayTags.contains(highway) || maxSpeed > 0 && maxSpeed <= 30) { if (maxSpeed < avoidSpeedLimit) { if (classBicycleValue != null) { weightToPrioMap.put(100d, convertClassValueToPriority(classBicycleValue).getValue()); } else { String classBicycle = way.getTag("class:bicycle"); if (classBicycle != null) weightToPrioMap.put(100d, convertClassValueToPriority(classBicycle).getValue());
/** * In this method we prefer cycleways or roads with designated bike access and avoid big roads * or roads with trams or pedestrian. * <p> * * @return new priority based on priorityFromRelation and on the tags in ReaderWay. */ protected int handlePriority(ReaderWay way, double wayTypeSpeed, int priorityFromRelation) { TreeMap<Double, Integer> weightToPrioMap = new TreeMap<>(); if (priorityFromRelation == 0) weightToPrioMap.put(0d, UNCHANGED.getValue()); else weightToPrioMap.put(110d, priorityFromRelation); collect(way, wayTypeSpeed, weightToPrioMap); // pick priority with biggest order value return weightToPrioMap.lastEntry().getValue(); }
@Override public long handleRelationTags(ReaderRelation relation, long oldRelationFlags) { oldRelationFlags = super.handleRelationTags(relation, oldRelationFlags); int code = 0; if (relation.hasTag("route", "mtb")) code = PREFER.getValue(); int oldCode = (int) relationCodeEncoder.getValue(oldRelationFlags); if (oldCode < code) return relationCodeEncoder.setValue(0, code); return oldRelationFlags; }
@Test public void testGetSpeed() { long result = encoder.setProperties(10, true, true); assertEquals(10, encoder.getSpeed(result), 1e-1); ReaderWay way = new ReaderWay(1); way.setTag("highway", "primary"); assertEquals(18, encoder.getSpeed(way)); assertPriority(REACH_DEST.getValue(), way); assertEquals(16, encoder.getSpeed(way)); assertPriority(PREFER.getValue(), way); assertEquals(4, encoder.getSpeed(way)); assertPriority(AVOID_IF_POSSIBLE.getValue(), way); assertEquals(18, encoder.getSpeed(way)); assertPriority(PREFER.getValue(), way); assertEquals(4, encoder.getSpeed(way)); assertPriority(AVOID_IF_POSSIBLE.getValue(), way); way.clearTags(); assertEquals(18, encoder.getSpeed(way)); assertPriority(PREFER.getValue(), way); assertEquals(18, encoder.getSpeed(way)); assertPriority(VERY_NICE.getValue(), way); way.setTag("highway", "path"); way.setTag("surface", "ground");
protected long handleSpeed(ReaderWay way, double speed, long encoded) { encoded = setSpeed(encoded, speed); // handle oneways boolean isOneway = way.hasTag("oneway", oneways) || way.hasTag("oneway:bicycle", oneways) || way.hasTag("vehicle:backward") || way.hasTag("vehicle:forward") || way.hasTag("bicycle:forward"); if ((isOneway || way.hasTag("junction", "roundabout")) && !way.hasTag("oneway:bicycle", "no") && !way.hasTag("bicycle:backward") && !way.hasTag("cycleway", oppositeLanes) && !way.hasTag("cycleway:left", oppositeLanes) && !way.hasTag("cycleway:right", oppositeLanes)) { boolean isBackward = way.hasTag("oneway", "-1") || way.hasTag("oneway:bicycle", "-1") || way.hasTag("vehicle:forward", "no") || way.hasTag("bicycle:forward", "no"); if (isBackward) encoded |= backwardBit; else encoded |= forwardBit; } else { encoded |= directionBitMask; } return encoded; }
@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); }
@Test public void testCalcPriority() { long allowed = encoder.acceptBit; ReaderWay osmWay = new ReaderWay(1); ReaderRelation osmRel = new ReaderRelation(1); osmRel.setTag("route", "bicycle"); osmRel.setTag("network", "icn"); long relFlags = encoder.handleRelationTags(osmRel, 0); long flags = encoder.handleWayTags(osmWay, allowed, relFlags); assertEquals((double) BEST.getValue() / BEST.getValue(), encoder.getDouble(flags, PriorityWeighting.KEY), 1e-3); // important: UNCHANGED should not get 0 priority! osmWay = new ReaderWay(1); osmWay.setTag("highway", "somethingelse"); flags = encoder.handleWayTags(osmWay, allowed, 0); assertEquals((double) UNCHANGED.getValue() / BEST.getValue(), encoder.getDouble(flags, PriorityWeighting.KEY), 1e-3); }
way.setTag("junction", "roundabout"); way.setTag("highway", "tertiary"); long flags = encoder.handleWayTags(way, encoder.acceptWay(way), 0); assertTrue(encoder.isBool(flags, FlagEncoder.K_ROUNDABOUT)); flags = encoder.handleWayTags(way, encoder.acceptWay(way), 0); assertTrue(encoder.isBool(flags, FlagEncoder.K_ROUNDABOUT));
&& ((way.hasTag("foot", "yes") && way.hasTag("segregated", "yes")) || way.hasTag("bicycle", "designated") || way.hasTag("bicycle", "official"))) highwaySpeed = getHighwaySpeed("cycleway");
@Test @Override public void testService() { ReaderWay way = new ReaderWay(1); way.setTag("highway", "service"); assertEquals(12, encoder.getSpeed(way)); assertPriority(UNCHANGED.getValue(), way); way.setTag("service", "parking_aisle"); assertEquals(6, encoder.getSpeed(way)); assertPriority(AVOID_IF_POSSIBLE.getValue(), way); }
protected void assertPriority(int expectedPrio, ReaderWay way, long relationFlags) { assertEquals(expectedPrio, encoder.handlePriority(way, 18, (int) encoder.relationCodeEncoder.getValue(relationFlags))); }
@Test public void testReduceToMaxSpeed() { ReaderWay way = new ReaderWay(12); way.setTag("maxspeed", "90"); assertEquals(12, encoder.applyMaxSpeed(way, 12), 1e-2); }
osmWay.setTag("highway", "tertiary"); osmWay.setTag("maxspeed", "50"); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(osmWay, 20))), 1e-1); assertPriority(PREFER.getValue(), osmWay); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(osmWay, 20))), 1e-1); assertPriority(PREFER.getValue(), osmWay); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(osmWay, 20))), 1e-1); assertPriority(PREFER.getValue(), osmWay); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(osmWay, 20))), 1e-1); assertPriority(UNCHANGED.getValue(), osmWay); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(osmWay, 20))), 1e-1); assertPriority(UNCHANGED.getValue(), osmWay); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(osmWay, 20))), 1e-1); assertPriority(REACH_DEST.getValue(), osmWay); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(osmWay, 20))), 1e-1); assertPriority(AVOID_AT_ALL_COSTS.getValue(), osmWay); osmWay.setTag("tunnel", "yes"); osmWay.setTag("maxspeed", "80"); assertEquals(20, encoder.getSpeed(encoder.setSpeed(0, encoder.applyMaxSpeed(osmWay, 20))), 1e-1); assertPriority(AVOID_AT_ALL_COSTS.getValue(), osmWay); osmWay.setTag("tunnel", "yes");