public Route prepend(final Edge edge) { return prepend(Route.forEdge(edge)); }
@Test public void testReverse() { final Atlas biDirectionalAtlas = this.rule.getBiDirectionalEdgeAtlas(); final Route singleBiDirectionalEdgeRoute = Route .forEdge(biDirectionalAtlas.edge(159019301)); Assert.assertEquals("There is a reverse route since it's a bi-directional edge", Route.forEdge(biDirectionalAtlas.edge(-159019301)), singleBiDirectionalEdgeRoute.reverse().get()); final Route multipleBirectionalEdgeRoute = Route.forEdges( biDirectionalAtlas.edge(159019301), biDirectionalAtlas.edge(28620796), biDirectionalAtlas.edge(138620888)); Assert.assertEquals("There is a reverse route since all the edges are bi-directional", Route.forEdges(biDirectionalAtlas.edge(-138620888), biDirectionalAtlas.edge(-28620796), biDirectionalAtlas.edge(-159019301)), multipleBirectionalEdgeRoute.reverse().get()); final Atlas uniDirectionalAtlas = this.rule.getUniDirectionalEdgeAtlas(); final Route singleUniDirectionalEdgeRoute = Route .forEdge(uniDirectionalAtlas.edge(28620796)); Assert.assertFalse("There is no reverse route since this is a one-way edge", singleUniDirectionalEdgeRoute.reverse().isPresent()); final Route routeWithUniDirectionalEdgeInBetween = Route.forEdges( uniDirectionalAtlas.edge(159019301), uniDirectionalAtlas.edge(28620796), uniDirectionalAtlas.edge(138620888)); Assert.assertFalse( "There is no reverse route since the middle edge is a uni-directional edge", routeWithUniDirectionalEdgeInBetween.reverse().isPresent()); }
@Test public void testStartsWith() { final Atlas atlas = this.rule.getAtlas(); final Route route = Route.forEdges(atlas.edge(159019301), atlas.edge(128620751), atlas.edge(128620796)); final Route duplicateRoute = Route.forEdges(atlas.edge(159019301), atlas.edge(128620751), atlas.edge(128620796)); final Route multiRoute = Route.forEdges(atlas.edge(159019301), atlas.edge(128620751)); final Route singleRoute = Route.forEdges(atlas.edge(159019301)); final Route incorrectMultiRoute = Route.forEdges(atlas.edge(159019301), atlas.edge(128620751), atlas.edge(138620888)); final Route incorrectSingleRoute = Route.forEdge(atlas.edge(128620751)); Assert.assertTrue("Verify startsWith returns true when passing in the same route", route.startsWith(duplicateRoute)); Assert.assertTrue("Verify startsWith returns true for a multiRoute", route.startsWith(multiRoute)); Assert.assertTrue("Verify startsWith returns true for a singleRoute", route.startsWith(singleRoute)); Assert.assertFalse("Verify a startsWith negative case for a multiRoute", route.startsWith(incorrectMultiRoute)); Assert.assertFalse("Verify a startsWith negative case for a singleRoute", route.startsWith(incorrectSingleRoute)); Assert.assertFalse( "Verify startsWith returns false when other route is longer than current route", singleRoute.startsWith(multiRoute)); }
private boolean isDualCarriageWayJunctionEdge(final Edge candidateEdge) { return isDualCarriageWayRoute(Route.forEdge(candidateEdge)); }
public Route append(final Edge edge) { return append(Route.forEdge(edge)); }
final Route partialLongerRoute = Route.forEdges(atlas.edge(128620751), atlas.edge(128620796)); final Route middleEdgeRoute = Route.forEdge(atlas.edge(128620751));
/** * Create a {@link Route} from an {@link Iterable} of {@link Edge}s that are already in the * proper order to be connected. * * @param edges * The {@link Edge}s to link in a {@link Route} * @return The corresponding {@link Route} */ public static Route forEdges(final Iterable<Edge> edges) { if (!edges.iterator().hasNext()) { throw new CoreException("Cannot have no edges"); } int counter = 0; Route result = null; for (final Edge edge : edges) { if (counter == 0) { result = Route.forEdge(edge); } else { result = result.append(edge); } counter++; } return result; }
Assert.assertEquals(Route.forEdge(atlas.edge(1)), router.route(atlas.edge(1), atlas.edge(1))); Assert.assertEquals(Route.forEdges(atlas.edge(1), atlas.edge(2)),
@Override public Optional<Route> reverse() { Route reversed = null; final Iterator<Edge> iterator = this.iterator(); while (iterator.hasNext()) { final Edge edge = iterator.next(); if (edge.hasReverseEdge()) { final Edge reverse = edge.reversed().orElseThrow( () -> new CoreException("Edge should have a reverse edge.")); if (reversed == null) { reversed = Route.forEdge(reverse); } else { reversed = reversed.prepend(reverse); } } else { return Optional.empty(); } } return Optional.ofNullable(reversed); }
/** * @return The set of {@link Route} that are emaning from the Via route, but which are not the * current To option. */ protected Set<Route> otherToOptions() { final Set<Route> result = new HashSet<>(); for (final Edge toEdge : this.too.start().start().outEdges()) { if (toEdge.equals(this.too.start())) { continue; } result.add(Route.forEdge(toEdge)); } return result; }
ComplexHighwayAreaHelper(final Edge edge) { this.sourceEdge = edge; buildHighwayAreaBoundary(Route.forEdge(edge)).ifPresent(route -> { this.boundary = route.asPolyLine(); StreamSupport.stream(route.spliterator(), false).map(Edge::getIdentifier) .forEach(this.visitedEdgeIdentifiers::add); this.sourceEdge = edge.getAtlas().edge(this.visitedEdgeIdentifiers.first()); }); if (this.boundary == null) { this.oops = new CoreException("Unable to build boundary for edge {}", edge.getOsmIdentifier()); } }
Route.forEdge(candidateEdge)); ? junctionEdgeIds.iterator().next() : junctionRouteEdgeIds.iterator().next(); final Edge candidate = atlas.edge(candidateEdgeId); final Route mergedCandidate = mergeJunctionEdges(Route.forEdge(candidate), junctionEdgeIds); logger.debug("Merged bigNode Route : {}. Number of Edges : {}", mergedCandidate,
@Override public Route route(final Edge start, final Edge end) { if (start == null || end == null) { throw new CoreException( "Cannot compute route on null arguments: start = {} and end = {}", start, end); } if (start.equals(end)) { // Same edge return Route.forEdge(start); } if (start.end().equals(end.start())) { // Directly connected edges return Route.forEdge(start).append(end); } final Route result = route(start.end(), end.start()); if (result != null) { // Re-populate the result with the start and end edges return Route.forEdge(start).append(result).append(end); } return null; }
return mergeJunctionEdges(Route.forEdge(mergeCandidate).append(candidateRoute), junctionEdgeIds);
Route route = Route.forEdge(atlas.edge(bigNodeRoute.start().getIdentifier())); for (int index = 1; index < bigNodeRoute.size(); index++)
route = Route.forEdge(members.iterator().next());
Route route = Route.forEdge(atlas.edge(bigNodeRoute.start().getIdentifier())); for (int index = 1; index < bigNodeRoute.size(); index++)
@Before public void init() { this.atlas = new PackedAtlasTest().getAtlas(); final Edge edge1 = this.atlas.edge(98); final Edge edge2 = this.atlas.edge(987); this.route = Route.forEdge(edge1); this.route = this.route.append(edge2); }