Skip to content

Commit

Permalink
make readFlags private, remove unnecessary int set and remove QueryGr…
Browse files Browse the repository at this point in the history 
…aph.getOriginalEdgeFromVirtNode, #1938
  • Loading branch information
@karussell
karussell committed Feb 29, 2020
1 parent 7d1f8c8 commit 8d15708
Show file tree
Hide file tree
Showing 3 changed files with 62 additions and 64 deletions.
4 changes: 0 additions & 4 deletions core/src/main/java/com/graphhopper/routing/querygraph/QueryGraph.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -118,10 +118,6 @@ public Graph getBaseGraph() {
return baseGraph;
}

public EdgeIteratorState getOriginalEdgeFromVirtNode(int nodeId) {
return getEdgeIteratorState(graphModification.getClosestEdges().get(nodeId - mainNodes), Integer.MIN_VALUE);
}

public boolean isVirtualEdge(int edgeId) {
return edgeId >= mainEdges;
}
Expand Down
4 changes: 1 addition & 3 deletions core/src/main/java/com/graphhopper/storage/TurnCostStorage.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -198,15 +198,13 @@ public double getExpensive(String name, EncodedValueLookup lookup, int fromEdge,
* @return the turn cost of the viaNode when going from "fromEdge" to "toEdge"
*/
public double get(DecimalEncodedValue turnCostEnc, IntsRef tcFlags, int fromEdge, int viaNode, int toEdge) {
// reset is required as we could have a QueryGraph that does not set tcFlags
tcFlags.ints[0] = 0;

This comment has been minimized.

Sign in to view

Copy link
@easbar

easbar Feb 29, 2020 •
edited
Loading

Member

Nice! This commit did clean up some things 👍

This comment has been minimized.

Sign in to view

Copy link
@karussell

karussell Feb 29, 2020

Author Member

Yes! Still, if we would have cleaned it up earlier, then we would have a much harder time to find the problems in #1938 :)
return turnCostEnc.getDecimal(false, readFlags(tcFlags, fromEdge, viaNode, toEdge));
}

/**
* @return turn cost flags of the specified triple "from edge", "via node" and "to edge"
*/
public IntsRef readFlags(IntsRef tcFlags, int fromEdge, int viaNode, int toEdge) {
private IntsRef readFlags(IntsRef tcFlags, int fromEdge, int viaNode, int toEdge) {
if (!EdgeIterator.Edge.isValid(fromEdge) || !EdgeIterator.Edge.isValid(toEdge))
throw new IllegalArgumentException("from and to edge cannot be NO_EDGE");
if (viaNode < 0)
Expand Down
118 changes: 61 additions & 57 deletions reader-osm/src/test/java/com/graphhopper/reader/osm/OSMReaderTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -519,28 +519,28 @@ public void testTurnRestrictions() {
// (4-3)->(3-8) no_right_turn = (4-3)->(3-8) restricted
IntsRef tcFlags = TurnCost.createFlags();
DecimalEncodedValue carTCEnc = hopper.getEncodingManager().getDecimalEncodedValue(TurnCost.key("car"));
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_8)) > 0);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_3, n3, edge3_8)) > 0);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_4)) == 0);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_2)) == 0);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_4)) == 0);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_3, n3, edge3_2)) == 0);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge8_3, n3, edge3_2)) == 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge2_3, n3, edge3_8) > 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge4_3, n3, edge3_8) > 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge2_3, n3, edge3_4) == 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge2_3, n3, edge3_2) == 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge2_3, n3, edge3_4) == 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge4_3, n3, edge3_2) == 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge8_3, n3, edge3_2) == 0);

// u-turn restriction for (6-1)->(1-6) but not for (1-6)->(6-1)
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge1_6, n1, edge1_6)) > 0);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge1_6, n6, edge1_6)) == 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge1_6, n1, edge1_6) > 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge1_6, n6, edge1_6) == 0);

int edge4_5 = GHUtility.getEdge(graph, n4, n5).getEdge();
int edge5_6 = GHUtility.getEdge(graph, n5, n6).getEdge();
int edge5_1 = GHUtility.getEdge(graph, n5, n1).getEdge();

// (4-5)->(5-1) right_turn_only = (4-5)->(5-6) restricted
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_5, n5, edge5_6)) == 0);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_5, n5, edge5_1)) > 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge4_5, n5, edge5_6) == 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge4_5, n5, edge5_1) > 0);

DecimalEncodedValue bikeTCEnc = hopper.getEncodingManager().getDecimalEncodedValue(TurnCost.key("bike"));
assertTrue(bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_5, n5, edge5_6)) == 0);
assertTrue(tcStorage.get(bikeTCEnc, tcFlags, edge4_5, n5, edge5_6) == 0);

int n10 = AbstractGraphStorageTester.getIdOf(graph, 40, 10);
int n11 = AbstractGraphStorageTester.getIdOf(graph, 40, 11);
Expand All @@ -549,10 +549,11 @@ public void testTurnRestrictions() {
int edge10_11 = GHUtility.getEdge(graph, n10, n11).getEdge();
int edge11_14 = GHUtility.getEdge(graph, n11, n14).getEdge();

assertTrue(tcStorage.readFlags(tcFlags, edge11_14, n11, edge10_11).isEmpty());
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge11_14, n11, edge10_11) == 0);
assertTrue(tcStorage.get(bikeTCEnc, tcFlags, edge11_14, n11, edge10_11) == 0);

assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge10_11, n11, edge11_14)) == 0);
assertTrue(bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge10_11, n11, edge11_14)) > 0);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge10_11, n11, edge11_14) == 0);
assertTrue(tcStorage.get(bikeTCEnc, tcFlags, edge10_11, n11, edge11_14) > 0);
}

@Test
Expand Down Expand Up @@ -742,22 +743,25 @@ public String toString() {
TurnCostStorage tcStorage = graph.getTurnCostStorage();

IntsRef tcFlags = TurnCost.createFlags();
tcStorage.readFlags(tcFlags, GHUtility.getEdge(graph, 1, 0).getEdge(), 0, GHUtility.getEdge(graph, 0, 2).getEdge());
int edge1 = GHUtility.getEdge(graph, 1, 0).getEdge();
int edge2 = GHUtility.getEdge(graph, 0, 2).getEdge();
// the 2nd entry provides turn flags for bike only
assertTrue(Double.isInfinite(carTCEnc.getDecimal(false, tcFlags)));
assertTrue(Double.isInfinite(truckTCEnc.getDecimal(false, tcFlags)));
assertEquals(0, bikeTCEnc.getDecimal(false, tcFlags), .1);
assertTrue(Double.isInfinite(tcStorage.get(carTCEnc, tcFlags, edge1, 0, edge2)));
assertTrue(Double.isInfinite(tcStorage.get(truckTCEnc, tcFlags, edge1, 0, edge2)));
assertEquals(0, tcStorage.get(bikeTCEnc, tcFlags, edge1, 0, edge2), .1);

tcStorage.readFlags(tcFlags, GHUtility.getEdge(graph, 2, 0).getEdge(), 0, GHUtility.getEdge(graph, 0, 3).getEdge());
edge1 = GHUtility.getEdge(graph, 2, 0).getEdge();
edge2 = GHUtility.getEdge(graph, 0, 3).getEdge();
// the first entry provides turn flags for car and foot only
assertEquals(0, carTCEnc.getDecimal(false, tcFlags), .1);
assertEquals(0, truckTCEnc.getDecimal(false, tcFlags), .1);
assertTrue(Double.isInfinite(bikeTCEnc.getDecimal(false, tcFlags)));
assertEquals(0, tcStorage.get(carTCEnc, tcFlags, edge1, 0, edge2), .1);
assertEquals(0, tcStorage.get(truckTCEnc, tcFlags, edge1, 0, edge2), .1);
assertTrue(Double.isInfinite(tcStorage.get(bikeTCEnc, tcFlags, edge1, 0, edge2)));

tcStorage.readFlags(tcFlags, GHUtility.getEdge(graph, 3, 0).getEdge(), 0, GHUtility.getEdge(graph, 0, 2).getEdge());
assertEquals(0, carTCEnc.getDecimal(false, tcFlags), .1);
assertTrue(Double.isInfinite(truckTCEnc.getDecimal(false, tcFlags)));
assertEquals(0, bikeTCEnc.getDecimal(false, tcFlags), .1);
edge1 = GHUtility.getEdge(graph, 3, 0).getEdge();
edge2 = GHUtility.getEdge(graph, 0, 2).getEdge();
assertEquals(0, tcStorage.get(carTCEnc, tcFlags, edge1, 0, edge2), .1);
assertTrue(Double.isInfinite(tcStorage.get(truckTCEnc, tcFlags, edge1, 0, edge2)));
assertEquals(0, tcStorage.get(bikeTCEnc, tcFlags, edge1, 0, edge2), .1);
}

@Test
Expand Down Expand Up @@ -797,36 +801,36 @@ public void testConditionalTurnRestriction() {

IntsRef tcFlags = TurnCost.createFlags();
DecimalEncodedValue carTCEnc = hopper.getEncodingManager().getDecimalEncodedValue(TurnCost.key("car"));
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_8)) > 0);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_3, n3, edge3_8)) > 0);
assertEquals(0, carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_4)), .1);
assertEquals(0, carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_2)), .1);
assertEquals(0, carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_4)), .1);
assertEquals(0, carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_3, n3, edge3_2)), .1);
assertEquals(0, carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge8_3, n3, edge3_2)), .1);
assertTrue(tcStorage.get(carTCEnc, tcFlags, edge2_3, n3, edge3_8) > 0);
assertTrue(tcStorage.get(carTCEnc,tcFlags, edge4_3, n3, edge3_8) > 0);
assertEquals(0, tcStorage.get(carTCEnc,tcFlags, edge2_3, n3, edge3_4), .1);
assertEquals(0, tcStorage.get(carTCEnc,tcFlags, edge2_3, n3, edge3_2), .1);
assertEquals(0, tcStorage.get(carTCEnc,tcFlags, edge2_3, n3, edge3_4), .1);
assertEquals(0, tcStorage.get(carTCEnc,tcFlags, edge4_3, n3, edge3_2), .1);
assertEquals(0, tcStorage.get(carTCEnc,tcFlags, edge8_3, n3, edge3_2), .1);

DecimalEncodedValue bikeTCEnc = hopper.getEncodingManager().getDecimalEncodedValue(TurnCost.key("bike"));
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_8)), .1);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_3, n3, edge3_8)), .1);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_4)), .1);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_2)), .1);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge2_3, n3, edge3_4)), .1);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_3, n3, edge3_2)), .1);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge8_3, n3, edge3_2)), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge2_3, n3, edge3_8), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge4_3, n3, edge3_8), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge2_3, n3, edge3_4), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge2_3, n3, edge3_2), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge2_3, n3, edge3_4), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge4_3, n3, edge3_2), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge8_3, n3, edge3_2), .1);

// u-turn except bus;bicycle restriction for (6-1)->(1-6) but not for (1-6)->(6-1)
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge1_6, n1, edge1_6)) > 0);
assertEquals(0, carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge1_6, n6, edge1_6)), .1);
assertTrue(tcStorage.get(carTCEnc,tcFlags, edge1_6, n1, edge1_6) > 0);
assertEquals(0, tcStorage.get(carTCEnc,tcFlags, edge1_6, n6, edge1_6), .1);

assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge1_6, n1, edge1_6)), .1);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge1_6, n6, edge1_6)), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge1_6, n1, edge1_6), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge1_6, n6, edge1_6), .1);

// (4-5)->(5-6) right_turn_only dedicated to motorcar = (4-5)->(5-1) restricted
assertEquals(0, carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_5, n5, edge5_6)), .1);
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_5, n5, edge5_1)) > 0);
assertEquals(0, tcStorage.get(carTCEnc,tcFlags, edge4_5, n5, edge5_6), .1);
assertTrue(tcStorage.get(carTCEnc,tcFlags, edge4_5, n5, edge5_1) > 0);

assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_5, n5, edge5_6)), .1);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_5, n5, edge5_1)), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge4_5, n5, edge5_6), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge4_5, n5, edge5_1), .1);
}

@Test
Expand Down Expand Up @@ -857,20 +861,20 @@ public void testMultipleTurnRestrictions() {
DecimalEncodedValue bikeTCEnc = hopper.getEncodingManager().getDecimalEncodedValue(TurnCost.key("bike"));

// (1-2)->(2-3) no_right_turn for motorcar and bus
assertTrue(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge1_2, n2, edge2_3)) > 0);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge1_2, n2, edge2_3)), .1);
assertTrue(tcStorage.get(carTCEnc,tcFlags, edge1_2, n2, edge2_3) > 0);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge1_2, n2, edge2_3), .1);

// (3-4)->(4-5) no_right_turn for motorcycle and motorcar
assertTrue(Double.isInfinite(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge3_4, n4, edge4_5))));
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge3_4, n4, edge4_5)), .1);
assertTrue(Double.isInfinite(tcStorage.get(carTCEnc,tcFlags, edge3_4, n4, edge4_5)));
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge3_4, n4, edge4_5), .1);

// (5-1)->(1-2) no_right_turn for bus and psv except for motorcar and bicycle
assertEquals(0, carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_5, n5, edge5_1)), .1);
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge4_5, n5, edge5_1)), .1);
assertEquals(0, tcStorage.get(carTCEnc,tcFlags, edge4_5, n5, edge5_1), .1);
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge4_5, n5, edge5_1), .1);

// (5-1)->(1-2) no_right_turn for motorcar and motorcycle except for bus and bicycle
assertTrue(Double.isInfinite(carTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge5_1, n1, edge1_2))));
assertEquals(0, bikeTCEnc.getDecimal(false, tcStorage.readFlags(tcFlags, edge5_1, n1, edge1_2)), .1);
assertTrue(Double.isInfinite(tcStorage.get(carTCEnc,tcFlags, edge5_1, n1, edge1_2)));
assertEquals(0, tcStorage.get(bikeTCEnc,tcFlags, edge5_1, n1, edge1_2), .1);
}

@Test
Expand Down

0 comments on commit 8d15708

Please sign in to comment.