EncodingManager createEncodingManager(boolean restrictedOnly) { if (restrictedOnly) carEncoder = new CarFlagEncoder(5, 5, 1); else // allow for basic costs too carEncoder = new CarFlagEncoder(5, 5, 3); return new EncodingManager(carEncoder); }
@Test public void testIssue_1256() { ReaderWay way = new ReaderWay(1); way.setTag("route", "ferry"); way.setTag("estimated_distance", 257); CarFlagEncoder lowFactorCar = new CarFlagEncoder(10, 1, 0); lowFactorCar.defineWayBits(0,0); assertEquals(2.5, encoder.getFerrySpeed(way), .1); assertEquals(.5, lowFactorCar.getFerrySpeed(way), .1); } }
@Test public void testSetAccess() { assertTrue(encoder.isForward(encoder.setProperties(0, true, true))); assertTrue(encoder.isBackward(encoder.setProperties(0, true, true))); assertTrue(encoder.isForward(encoder.setProperties(0, true, false))); assertFalse(encoder.isBackward(encoder.setProperties(0, true, false))); assertFalse(encoder.isForward(encoder.setProperties(0, false, true))); assertTrue(encoder.isBackward(encoder.setProperties(0, false, true))); assertTrue(encoder.isForward(encoder.flagsDefault(true, true))); assertTrue(encoder.isBackward(encoder.flagsDefault(true, true))); assertTrue(encoder.isForward(encoder.flagsDefault(true, false))); assertFalse(encoder.isBackward(encoder.flagsDefault(true, false))); long flags = encoder.flagsDefault(true, true); // disable access assertFalse(encoder.isForward(encoder.setAccess(flags, false, false))); assertFalse(encoder.isBackward(encoder.setAccess(flags, false, false))); }
@Override public long handleWayTags(ReaderWay way, long allowed, long relationFlags) { if (!isAccept(allowed)) return 0; if (!isFerry(allowed)) { double speed = getSpeed(way); speed = applyMaxSpeed(way, speed); speed = applyBadSurfaceSpeed(way, speed); flags = setSpeed(flags, speed); flags = setBool(flags, K_ROUNDABOUT, true); if (isOneway(way) || isRoundabout) { if (isBackwardOneway(way)) flags |= backwardBit; if (isForwardOneway(way)) flags |= forwardBit; } else double ferrySpeed = getFerrySpeed(way); flags = setSpeed(flags, ferrySpeed); flags |= directionBitMask; flags = setSpeed(flags, destinationSpeed);
@Test public void testSwapDir() { long swappedFlags = encoder.reverseFlags(encoder.flagsDefault(true, true)); assertTrue(encoder.isForward(swappedFlags)); assertTrue(encoder.isBackward(swappedFlags)); swappedFlags = encoder.reverseFlags(encoder.flagsDefault(true, false)); assertFalse(encoder.isForward(swappedFlags)); assertTrue(encoder.isBackward(swappedFlags)); assertEquals(0, encoder.reverseFlags(0)); }
public CarFlagEncoder(PMap properties) { this((int) properties.getLong("speed_bits", 5), properties.getDouble("speed_factor", 5), properties.getBool("turn_costs", false) ? 1 : 0); this.properties = properties; this.setBlockFords(properties.getBool("block_fords", true)); this.setBlockByDefault(properties.getBool("block_barriers", true)); }
@Test public void testSetSpeed0_issue367() { long flags = encoder.setProperties(10, true, true); flags = encoder.setSpeed(flags, encoder.speedFactor * 0.49); assertEquals(0, encoder.getSpeed(flags), .1); assertEquals(0, encoder.getReverseSpeed(flags), .1); assertFalse(encoder.isForward(flags)); assertFalse(encoder.isBackward(flags)); }
@Test public void testMaxValue() { CarFlagEncoder instance = new CarFlagEncoder(10, 0.5, 0); EncodingManager em = new EncodingManager(instance); ReaderWay way = new ReaderWay(1); way.setTag("highway", "motorway_link"); way.setTag("maxspeed", "60 mph"); long flags = instance.handleWayTags(way, 1, 0); // double speed = AbstractFlagEncoder.parseSpeed("60 mph"); // => 96.56 * 0.9 => 86.9 assertEquals(86.9, instance.getSpeed(flags), 1e-1); flags = instance.reverseFlags(flags); assertEquals(86.9, instance.getSpeed(flags), 1e-1); // test that maxPossibleValue is not exceeded way = new ReaderWay(2); way.setTag("highway", "motorway_link"); way.setTag("maxspeed", "70 mph"); flags = instance.handleWayTags(way, 1, 0); assertEquals(101.5, instance.getSpeed(flags), .1); }
way.setTag("highway", "secondary"); way.setTag("railway", "rail"); assertTrue(encoder.acceptWay(way) > 0); assertTrue(encoder.acceptWay(way) == 0); assertTrue(encoder.acceptWay(way) > 0); assertTrue(encoder.acceptWay(way) > 0); assertTrue(encoder.acceptWay(way) == 0); way.setTag("railway", "tram"); assertTrue(encoder.acceptWay(way) > 0); assertTrue(encoder.acceptWay(way) > 0); assertEquals(61, encoder.getFerrySpeed(way), 1e-1); assertTrue(encoder.acceptWay(way) > 0); assertEquals(2.5, encoder.getFerrySpeed(way), 1e-1); assertEquals(5, encoder.getSpeed(encoder.setSpeed(0, 2.5)), 1e-1); assertTrue(encoder.acceptWay(way) > 0); assertEquals(2.5, encoder.getFerrySpeed(way), 1e-1);
@Test public void testFordAccess() { ReaderNode node = new ReaderNode(0, 0.0, 0.0); node.setTag("ford", "yes"); ReaderWay way = new ReaderWay(1); way.setTag("highway", "unclassified"); way.setTag("ford", "yes"); // Node and way are initially blocking assertTrue(encoder.isBlockFords()); assertFalse(encoder.acceptWay(way) > 0); assertTrue(encoder.handleNodeTags(node) > 0); try { // Now they are passable encoder.setBlockFords(false); assertTrue(encoder.acceptWay(way) > 0); assertFalse(encoder.handleNodeTags(node) > 0); } finally { encoder.setBlockFords(true); } }
way.setTag("highway", "trunk"); way.setTag("maxspeed", "110"); long allowed = encoder.acceptWay(way); long encoded = encoder.handleWayTags(way, allowed, 0); assertEquals(100, encoder.getSpeed(encoded), 1e-1); allowed = encoder.acceptWay(way); encoded = encoder.handleWayTags(way, allowed, 0); assertEquals(30, encoder.getSpeed(encoded), 1e-1); allowed = encoder.acceptWay(way); encoded = encoder.handleWayTags(way, allowed, 0); assertEquals(15, encoder.getSpeed(encoded), 1e-1); allowed = encoder.acceptWay(way); encoded = encoder.handleWayTags(way, allowed, 0); assertEquals(20, encoder.getSpeed(encoded), 1e-1); allowed = encoder.acceptWay(way); encoded = encoder.handleWayTags(way, allowed, 0); assertEquals(30, encoder.getSpeed(encoded), 1e-1); allowed = encoder.acceptWay(way); encoded = encoder.handleWayTags(way, allowed, 0); assertEquals(90, encoder.getSpeed(encoded), 1e-1); allowed = encoder.acceptWay(way); encoded = encoder.handleWayTags(way, allowed, 0); assertEquals(100, encoder.getSpeed(encoded), 1e-1);
@Test public void testRoundabout() { long flags = encoder.setAccess(0, true, true); long resFlags = encoder.setBool(flags, FlagEncoder.K_ROUNDABOUT, true); assertTrue(encoder.isBool(resFlags, FlagEncoder.K_ROUNDABOUT)); assertTrue(encoder.isForward(resFlags)); assertTrue(encoder.isBackward(resFlags)); resFlags = encoder.setBool(flags, FlagEncoder.K_ROUNDABOUT, false); assertFalse(encoder.isBool(resFlags, FlagEncoder.K_ROUNDABOUT)); assertTrue(encoder.isForward(resFlags)); assertTrue(encoder.isBackward(resFlags)); ReaderWay way = new ReaderWay(1); way.setTag("highway", "motorway"); flags = encoder.handleWayTags(way, encoder.acceptBit, 0); assertTrue(encoder.isForward(flags)); assertTrue(encoder.isBackward(flags)); assertFalse(encoder.isBool(flags, FlagEncoder.K_ROUNDABOUT)); way.setTag("junction", "roundabout"); flags = encoder.handleWayTags(way, encoder.acceptBit, 0); assertTrue(encoder.isForward(flags)); assertFalse(encoder.isBackward(flags)); assertTrue(encoder.isBool(flags, FlagEncoder.K_ROUNDABOUT)); way.clearTags(); way.setTag("highway", "motorway"); way.setTag("junction", "circular"); flags = encoder.handleWayTags(way, encoder.acceptBit, 0); assertTrue(encoder.isForward(flags)); assertFalse(encoder.isBackward(flags)); assertTrue(encoder.isBool(flags, FlagEncoder.K_ROUNDABOUT)); }
if (restrictedValues.contains(firstValue) && !getConditionalTagInspector().isRestrictedWayConditionallyPermitted(way)) return 0; if (intendedValues.contains(firstValue)) if (isBlockFords() && ("ford".equals(highwayValue) || way.hasTag("ford"))) return 0; if (getConditionalTagInspector().isPermittedWayConditionallyRestricted(way)) return 0; else
@Test public void testUpdateFlags() { CarFlagEncoder carFlagEncoder = new CarFlagEncoder(); EncodingManager encodingManager = new EncodingManager(carFlagEncoder); FastestWeighting weighting = new FastestWeighting(carFlagEncoder); 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(); EdgeIteratorState iter = GHUtility.getEdge(g, 0, 1); assertEquals(1, iter.getAdjNode()); assertEquals(carFlagEncoder.setProperties(10, true, true), iter.getFlags()); iter.setFlags(carFlagEncoder.setProperties(20, true, false)); assertEquals(12, 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());
@Test public void testDestinationTag() { ReaderWay way = new ReaderWay(1); way.setTag("highway", "secondary"); assertEquals(60, encoder.getSpeed(way), 1e-1); way.setTag("vehicle", "destination"); long flags = encoder.handleWayTags(way, encoder.acceptWay(way), 0); assertEquals(5, encoder.getSpeed(flags), 1e-1); }
@Override public long reverseFlags(long flags) { // swap access flags = super.reverseFlags(flags); // swap speeds double otherValue = reverseSpeedEncoder.getDoubleValue(flags); flags = setReverseSpeed(flags, speedEncoder.getDoubleValue(flags)); return setSpeed(flags, otherValue); }
@Override public long flagsDefault(boolean forward, boolean backward) { long flags = super.flagsDefault(forward, backward); if (backward) return reverseSpeedEncoder.setDefaultValue(flags); return flags; }
/** * Define the place of the speedBits in the edge flags for car. */ @Override public int defineWayBits(int index, int shift) { // first two bits are reserved for route handling in superclass shift = super.defineWayBits(index, shift); reverseSpeedEncoder = new EncodedDoubleValue("Reverse Speed", shift, speedBits, speedFactor, defaultSpeedMap.get("secondary"), maxPossibleSpeed); shift += reverseSpeedEncoder.getBits(); priorityWayEncoder = new EncodedValue("PreferWay", shift, 3, 1, 3, 7); shift += priorityWayEncoder.getBits(); curvatureEncoder = new EncodedValue("Curvature", shift, 4, 1, 10, 10); shift += curvatureEncoder.getBits(); return shift; }
@Test public void testAcceptsCar() { CarFlagEncoder encoder = new CarFlagEncoder(5, 5, 0); assertEquals(40, encoder.parseSpeed("40 km/h"), 1e-3); assertEquals(40, encoder.parseSpeed("40km/h"), 1e-3); assertEquals(40, encoder.parseSpeed("40kmh"), 1e-3); assertEquals(64.374, encoder.parseSpeed("40mph"), 1e-3); assertEquals(48.28, encoder.parseSpeed("30 mph"), 1e-3); assertEquals(-1, encoder.parseSpeed(null), 1e-3); assertEquals(18.52, encoder.parseSpeed("10 knots"), 1e-3); assertEquals(19, encoder.parseSpeed("19 kph"), 1e-3); assertEquals(19, encoder.parseSpeed("19kph"), 1e-3); assertEquals(50, encoder.parseSpeed("RO:urban"), 1e-3); assertEquals(80, encoder.parseSpeed("RU:rural"), 1e-3); assertEquals(6, encoder.parseSpeed("walk"), 1e-3); }