@Override public boolean test(final Edge edge) { return edge.isMasterEdge() && edge.getOsmIdentifier() == this.osmIdentifier; } }
/** * Returns all connected master, non-visited {@link Edge}s that are a continuation of the same * OSM way * * @param edge * the {@link Edge} from which we're seeking connections * @return a set of {@link Edge}s */ protected Set<Edge> getConnectedMasterEdgeOfTheSameWay(final Edge edge) { return edge.connectedEdges().stream() .filter(connection -> connection.isMasterEdge() && connection.getOsmIdentifier() == edge.getOsmIdentifier() && !this.visitedEdges.contains(connection)) .collect(Collectors.toSet()); }
private boolean hasGoodMatch(final Edge edge, final Atlas other) { if (this.withGeometryMatching) { final Rectangle bounds = edge.bounds(); return hasPerfectMatch(edge, other.edgesIntersecting(bounds, otherEdge -> edge.getOsmIdentifier() == otherEdge.getOsmIdentifier())); } return false; }
/** * Constructs an {@link EdgeWalker} that collects all the {@link Edge}s that form a complete Way * * @param edge * any {@link Edge} section of the Way */ public OsmWayWalker(final Edge edge) { super(edge, new WaySectionComparator(), new MasterEdgeByOsmIdentifierFilter(edge.getOsmIdentifier()), CONNECTED_EDGES); }
/** * Constructs an {@link EdgeWalker} that collects all the {@link Edge}s that form a complete Way * * @param edge * any {@link Edge} section of the Way * @param edgeHandler * an EdgeHandler to collect statistics */ public OsmWayWalker(final Edge edge, final EdgeHandler edgeHandler) { super(edge, new WaySectionComparator(), new MasterEdgeByOsmIdentifierFilter(edge.getOsmIdentifier()), CONNECTED_EDGES, edgeHandler); } }
/** * Returns all connected master {@link Edge}s that are NOT part of the same way as the given * target {@link Edge} * * @param edge * the target {@link Edge} for which we're seeking connections * @return the {@link Set} of {@link Edge}s we found */ private Set<Edge> getMasterEdgesForConnectedEdgesOfDifferentWays(final Edge edge) { return Iterables.stream(edge.connectedEdges()).filter(candidate -> candidate.isMasterEdge() && candidate.getOsmIdentifier() != edge.getOsmIdentifier()).collectToSet(); }
building.getOsmIdentifier(), edge.getOsmIdentifier())); knownIntersections.add(edge); final Optional<Edge> reversedEdge = edge.reversed();
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()); } }
private boolean canAddEdgeToBoundary(final Edge edge, final Route boundary) { return edge.getIdentifier() != -boundary.end().getIdentifier() && edge.getOsmIdentifier() == boundary.end().getOsmIdentifier() && boundary.end().end().getLocation().equals(edge.start().getLocation()) && !boundary.includes(edge); } }
.filter(Edge::isMasterEdge).collect(Collectors.toSet()); connectedBadEdges .forEach(badEdge -> this.markAsFlagged(badEdge.getOsmIdentifier())); results = new HashSet<>(connectedBadEdges);
.forEach(validEdge -> this.markAsFlagged(validEdge.getOsmIdentifier())); return true;
@Override protected Optional<CheckFlag> flag(final AtlasObject object) { // Use EdgeWalker to gather all connected invalid crossings. The use of the walker prevents // edges from being flagged more than once. final Set<Edge> collectedEdges = new EdgeCrossingEdgeWalker((Edge) object, this.getInvalidCrossingEdges()).collectEdges(); if (collectedEdges.size() > 1) { final CheckFlag newFlag = new CheckFlag(getTaskIdentifier(object)); this.markAsFlagged(object.getIdentifier()); newFlag.addObject(object); newFlag.addInstruction(this.getLocalizedInstruction(0, object.getOsmIdentifier())); collectedEdges.forEach(invalidEdge -> { this.markAsFlagged(invalidEdge.getIdentifier()); newFlag.addObject(invalidEdge); newFlag.addInstruction( this.getLocalizedInstruction(1, invalidEdge.getOsmIdentifier())); }); return Optional.of(newFlag); } return Optional.empty(); }
outEdge.getOsmIdentifier(), OFF_RAMP_KEY, DestinationTag.KEY)); flag.addObject(outEdge); rampEdge.getOsmIdentifier(), ON_RAMP_KEY, DestinationTag.KEY)); flag.addObject(rampEdge);
this.getLocalizedInstruction(0, edgeInBounds.getOsmIdentifier())));
@Test public void testLoopingWayWithIntersection() { // Based on https://www.openstreetmap.org/way/310540517 and partial excerpt of // https://www.openstreetmap.org/way/310540519 final Atlas slicedRawAtlas = this.setup.getLoopingWayWithIntersectionAtlas(); final Atlas finalAtlas = new WaySectionProcessor(slicedRawAtlas, AtlasLoadingOption.createOptionWithAllEnabled(COUNTRY_BOUNDARY_MAP)).run(); Assert.assertEquals("Four edges, each having a reverse counterpart", 8, finalAtlas.numberOfEdges()); Assert.assertEquals("Four nodes", 4, finalAtlas.numberOfNodes()); Assert.assertTrue("This way got sectioned 3 times, with reverse edges", Iterables .size(finalAtlas.edges(edge -> edge.getOsmIdentifier() == 310540517L)) == 6); Assert.assertTrue("This edge got sectioned once, with reverse edges", Iterables .size(finalAtlas.edges(edge -> edge.getOsmIdentifier() == 310540519L)) == 2); }
Iterables.size(finalAtlas.edges(edge -> edge.getOsmIdentifier() == 608901269))); Assert.assertEquals(999, Iterables.size(finalAtlas.edges(edge -> edge.getOsmIdentifier() == 608903805)));
@Test public void testLoopWithRepeatedLocation() { // Based on a prior version of https://www.openstreetmap.org/way/488453376 with a piece of // https://www.openstreetmap.org/way/386313688 final Atlas slicedRawAtlas = this.setup.getLoopWithRepeatedLocationAtlas(); final Atlas finalAtlas = new WaySectionProcessor(slicedRawAtlas, AtlasLoadingOption.createOptionWithAllEnabled(COUNTRY_BOUNDARY_MAP)).run(); Assert.assertEquals("Four edges, each having a reverse counterpart", 4, finalAtlas.numberOfEdges()); Assert.assertEquals("Two nodes", 2, finalAtlas.numberOfNodes()); Assert.assertTrue("This way got sectioned once, with a reverse edge", Iterables .size(finalAtlas.edges(edge -> edge.getOsmIdentifier() == 488453376L)) == 2); }
@Test public void testLineWithRepeatedLocation() { // Based on a prior version of https://www.openstreetmap.org/way/488453376 final Atlas slicedRawAtlas = this.setup.getLineWithRepeatedLocationAtlas(); final Atlas finalAtlas = new WaySectionProcessor(slicedRawAtlas, AtlasLoadingOption.createOptionWithAllEnabled(COUNTRY_BOUNDARY_MAP)).run(); Assert.assertEquals("Four edges, each having a reverse counterpart", 4, finalAtlas.numberOfEdges()); Assert.assertEquals("Two nodes", 2, finalAtlas.numberOfNodes()); Assert.assertTrue("This way got sectioned 4 times, with reverse edges", Iterables .size(finalAtlas.edges(edge -> edge.getOsmIdentifier() == 488453376L)) == 4); }