public static CompleteEdge from(final Edge edge) { return new CompleteEdge(edge.getIdentifier(), edge.asPolyLine(), edge.getTags(), edge.start().getIdentifier(), edge.end().getIdentifier(), edge.relations().stream().map(Relation::getIdentifier).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; }
private static boolean aConnectedNodeHasValenceLessThan(final Edge edge, final int valence) { return edge // go through each connected node of given edge .connectedNodes().stream() // check if any of them has less than given valence value .anyMatch(node -> node.connectedEdges().stream() // counting only master edge connections .filter(Edge::isMasterEdge).count() < valence); }
@Override public boolean test(final Edge edge) { return edge.isMasterEdge() && edge.getOsmIdentifier() == this.osmIdentifier; } }
/** * Checks if edge is a master edge, by verifying that its identifier is a master edge * identifier. * * @return True if the edge's identifier is a master edge identifier */ public boolean isMasterEdge() { return isMasterEdgeIdentifier(this.getIdentifier()); }
@Override public String toDiffViewFriendlyString() { final String relationsString = this.parentRelationsAsDiffViewFriendlyString(); return "[Edge" + ": id=" + this.getIdentifier() + ", startNode=" + start().getIdentifier() + ", endNode=" + end().getIdentifier() + ", polyLine=" + this.asPolyLine().toWkt() + ", relations=(" + relationsString + "), " + tagString() + "]"; }
protected void validateReverseEdgePolyLineUpdated() { for (final Edge edge : this.atlas .edges(edge -> edge.hasReverseEdge() && edge.isMasterEdge())) { final Edge reversed = edge.reversed().orElseThrow(() -> new CoreException( "Edge {} should have a reverse, but does not.", edge.getIdentifier())); final PolyLine forward = edge.asPolyLine(); final PolyLine backward = reversed.asPolyLine(); if (!forward.equals(backward.reversed())) { throw new CoreException( "Edge {} and its reverse {} have mismatching PolyLines: Forward = {}, Backward = {}", edge.getIdentifier(), reversed.getIdentifier(), forward, backward); } } } }
for (final Edge edge : atlas.edges(JunctionTag::isRoundabout)) final PolyLine currentShape = edge.asPolyLine(); if (currentShape.size() > 2 && !edge.hasReverseEdge()) final PolyLine shape2 = currentShape.between(cut, 0, currentShape.last(), 0); final long middleNodeIdentifier = identifierGenerator.incrementAndGet(); final long oldEdgeIdentifier = edge.getIdentifier(); final long newEdgeIdentifier1 = identifierGenerator.incrementAndGet(); final long newEdgeIdentifier2 = identifierGenerator.incrementAndGet(); edge.relations().stream().map(relation -> result.add(FeatureChange.add(CompleteNode.shallowFrom(edge.end()) .withInEdges(edge.end().inEdges()) .withInEdgeIdentifierReplaced(oldEdgeIdentifier, newEdgeIdentifier2))); result.add(FeatureChange.add(CompleteNode.shallowFrom(edge.start()) .withOutEdges(edge.start().outEdges()) .withOutEdgeIdentifierReplaced(oldEdgeIdentifier, newEdgeIdentifier1)));
if (builder.peek().edge(edge.getIdentifier()) == null) builder.addEdge(edge.getIdentifier(), edge.asPolyLine(), edge.getTags()); if (edge.hasReverseEdge()) final Edge reverseEdge = edge.reversed().get(); // NOSONAR final long reverseEdgeIdentifier = reverseEdge.getIdentifier(); if (builder.peek().edge(reverseEdgeIdentifier) == null) builder.addEdge(reverseEdgeIdentifier, reverseEdge.asPolyLine(), reverseEdge.getTags());
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); } }
final HighwayTag highwayTag = edge.highwayTag(); final CheckFlag flag = new CheckFlag(this.getTaskIdentifier(object)); edge.end().outEdges().stream() .filter(connectedEdge -> isPossiblyRamp(edge, highwayTag, connectedEdge)) .forEach(outEdge -> final Node start = outEdge.start(); if (!Validators.isOfType(start, HighwayTag.class, HighwayTag.MOTORWAY_JUNCTION)) outEdge.getOsmIdentifier(), OFF_RAMP_KEY, DestinationTag.KEY)); flag.addObject(outEdge); edge.start().inEdges().stream() .filter(connectedEdge -> isPossiblyRamp(edge, highwayTag, connectedEdge)) .forEach(inEdge -> rampEdge.getOsmIdentifier(), ON_RAMP_KEY, DestinationTag.KEY)); flag.addObject(rampEdge);
/** * Flags the given edge and its reverse edge * * @param edge * The edge to flag */ private void flagEdge(final Edge edge) { this.markAsFlagged(edge.getIdentifier()); if (edge.hasReverseEdge()) { this.markAsFlagged(edge.reversed().get().getIdentifier()); } }
final PolyLine edgeAsPolyLine = edge.asPolyLine(); final Rectangle edgeBounds = edge.bounds(); final Atlas atlas = edge.getAtlas(); return Iterables .asList(atlas.edgesIntersecting(edgeBounds, crossingEdge -> edge.getIdentifier() != crossingEdge.getIdentifier() && this.isValidCrossingEdge(crossingEdge))) .stream() final PolyLine crossingEdgeAsPolyLine = crossingEdge.asPolyLine(); final Optional<Long> crossingEdgeLayer = Validators .hasValuesFor(crossingEdge, LayerTag.class)
.count() >= MIN_MASTER_EDGE_DUAL_CARRIAGEWAY_INTERSECTION) for (final Edge inEdge : candidateRoute.start().inEdges()) if (inEdge.highwayTag().isLessImportantThan(HighwayTag.RESIDENTIAL) || this.edgeDirectionComparator.isSameDirection(candidateRoute.start(), inEdge, false) for (final Edge outEdge : candidateRoute.end().outEdges()) if (outEdge.highwayTag().isMoreImportantThanOrEqualTo(HighwayTag.RESIDENTIAL) && this.edgeDirectionComparator.isOppositeDirection(inEdge, outEdge, false) && !outEdge.hasReverseEdge() && !inEdge.hasReverseEdge() && edgeNameFuzzyMatch(outEdge, inEdge, false))
/** * @return the master for this {@link Edge}, which may or may not be the master. */ public Edge getMasterEdge() { return this.isMasterEdge() ? this : this.reversed() .orElseThrow(() -> new CoreException( "Reverse edge should be available for edge {}", this.getIdentifier())); }
members.addItem(inEdge.getIdentifier(), "from", ItemType.EDGE); inEdge.reversed().ifPresent(reversed -> members .addItem(reversed.getIdentifier(), "from", ItemType.EDGE)); members.addItem(node.getIdentifier(), "via", ItemType.NODE); members.addItem(outEdge.getIdentifier(), "to", ItemType.EDGE); outEdge.reversed().ifPresent(reversed -> members .addItem(reversed.getIdentifier(), "to", ItemType.EDGE)); final Long relationIdentifier = identifierGenerator.incrementAndGet(); final Rectangle bounds = Rectangle.forLocated(inEdge, outEdge); result.add(FeatureChange .add(CompleteEdge.shallowFrom(inEdge).withRelationIdentifiers( mergeRelationMembers(inEdge.relations(), relationIdentifier)))); if (inEdge.hasReverseEdge()) FeatureChange.add(CompleteEdge.shallowFrom(inEdge.reversed().get()) .withRelationIdentifiers(mergeRelationMembers( inEdge.relations(), relationIdentifier)))); mergeRelationMembers(node.relations(), relationIdentifier)))); result.add(FeatureChange.add(CompleteEdge.shallowFrom(outEdge) .withRelationIdentifiers(mergeRelationMembers(outEdge.relations(), relationIdentifier)))); if (outEdge.hasReverseEdge()) FeatureChange.add(CompleteEdge.shallowFrom(outEdge.reversed().get()) .withRelationIdentifiers(mergeRelationMembers( outEdge.relations(), relationIdentifier))));
/** * 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()); }
Assert.assertTrue(getField(deserialized, PackedAtlas.FIELD_NODE_OUT_EDGES_INDICES) != null); logger.info("Got Node connected Edges {}", connectedEdges.stream() .map(edge -> edge.getIdentifier()).collect(Collectors.toList())); final Edge edge = deserialized.edge(edgeIdentifier); logger.info("Got Edge {}", edgeIdentifier); final PolyLine line = edge.asPolyLine(); Assert.assertTrue(getField(deserialized, PackedAtlas.FIELD_EDGE_POLY_LINES) != null); logger.info("Got Edge geometry {}", line); Assert.assertTrue(getField(deserialized, PackedAtlas.FIELD_EDGE_POLY_LINES) != null); final Set<Node> connectedNodes = edge.connectedNodes(); logger.info("Got Edge connected Nodes {}", connectedNodes.stream() .map(aNode -> aNode.getIdentifier()).collect(Collectors.toList())); final Map<String, String> edgeTags = edge.getTags(); logger.info("Got Edge tags {}", edgeTags); logger.info("{}", edge);
for (final Node node : edge.connectedNodes()) .forEach(validEdge -> this.markAsFlagged(validEdge.getOsmIdentifier())); return true; .forEach(invalidEdge -> this.isChecked.add(invalidEdge.getIdentifier())); return false;