@Override
public V getNextVertex(V source, V target) {
if (!containsEdge(source, target)) {
throw new NoSuchElementException("Edge not found.");
}
V next = graph.getNextVertex(source, target);
while (!vertices.contains(next)) {
next = graph.getNextVertex(next, target);
}
return next;
}
@Override
public V getPrevVertex(V source, V target) {
if (!containsEdge(source, target)) {
throw new NoSuchElementException("Edge not found.");
}
V prev = graph.getPrevVertex(source, target);
while (!vertices.contains(prev)) {
prev = graph.getPrevVertex(source, prev);
}
return prev;
}
@Override
public Set<E> getAllEdges(V source, V target) {
Set<E> edges = new HashSet<E>();
if (vertices.contains(source) && vertices.contains(target)) {
edges.addAll(graph.getAllEdges(source, target));
}
return edges;
}
@Override
public E getEdge(V source, V target) {
E edge = null;
if (containsEdge(source, target)) {
edge = graph.getEdge(source, target);
}
return edge;
}
@Override
public Set<E> edgesOf(V v) {
Set<E> edges = new LinkedHashSet<E>();
if (vertices.contains(v)) {
for (E edge : graph.edgesOf(v)) {
V target = Graphs.getOppositeVertex(graph, edge, v);
if (vertices.contains(target)) {
edges.add(edge);
}
}
}
return edges;
}
public Geometry buffer(Geometry g, double distance) {
PrecisionModel precisionModel = workingPrecisionModel;
if (precisionModel == null) precisionModel = g.getPrecisionModel();
// factory must be the same as the one used by the input
geomFact = g.getFactory();
OffsetCurveBuilder curveBuilder = new OffsetCurveBuilder(precisionModel, bufParams);
OffsetCurveSetBuilder curveSetBuilder = new OffsetCurveSetBuilder(g, distance, curveBuilder);
List bufferSegStrList = curveSetBuilder.getCurves();
// short-circuit test
if (bufferSegStrList.size() <= 0) {
return createEmptyResultGeometry();
}
// BufferDebug.runCount++;
// String filename = "run" + BufferDebug.runCount + "_curves";
// System.out.println("saving " + filename);
// BufferDebug.saveEdges(bufferEdgeList, filename);
// DEBUGGING ONLY
// WKTWriter wktWriter = new WKTWriter();
// Debug.println("Rings: " + wktWriter.write(convertSegStrings(bufferSegStrList.iterator())));
// wktWriter.setMaxCoordinatesPerLine(10);
// System.out.println(wktWriter.writeFormatted(convertSegStrings(bufferSegStrList.iterator())));
computeNodedEdges(bufferSegStrList, precisionModel);
graph = new PlanarGraph(new OverlayNodeFactory());
graph.addEdges(edgeList.getEdges());
List subgraphList = createSubgraphs(graph);
PolygonBuilder polyBuilder = new PolygonBuilder(geomFact);
buildSubgraphs(subgraphList, polyBuilder);
List resultPolyList = polyBuilder.getPolygons();
// just in case...
if (resultPolyList.size() <= 0) {
return createEmptyResultGeometry();
}
Geometry resultGeom = geomFact.buildGeometry(resultPolyList);
return resultGeom;
}
public void add(Edge edge) {
RoadSegment roadSegment = (RoadSegment) edge;
RoadNode startNode = getNode(roadSegment.getLine().getCoordinateN(0));
RoadNode endNode =
getNode(roadSegment.getLine().getCoordinateN(roadSegment.getLine().getNumPoints() - 1));
roadSegment.setStartNode(startNode);
roadSegment.setEndNode(endNode);
DirectedEdge directedEdge0 =
new DirectedEdge(startNode, endNode, roadSegment.getLine().getCoordinateN(1), true);
DirectedEdge directedEdge1 =
new DirectedEdge(
endNode,
startNode,
roadSegment.getLine().getCoordinateN(roadSegment.getLine().getNumPoints() - 2),
false);
roadSegment.setDirectedEdges(directedEdge0, directedEdge1);
super.add(roadSegment);
}
private List createSubgraphs(PlanarGraph graph) {
List subgraphList = new ArrayList();
for (Iterator i = graph.getNodes().iterator(); i.hasNext(); ) {
Node node = (Node) i.next();
if (!node.isVisited()) {
BufferSubgraph subgraph = new BufferSubgraph();
subgraph.create(node);
subgraphList.add(subgraph);
}
}
/**
* Sort the subgraphs in descending order of their rightmost coordinate. This ensures that when
* the Polygons for the subgraphs are built, subgraphs for shells will have been built before
* the subgraphs for any holes they contain.
*/
Collections.sort(subgraphList, Collections.reverseOrder());
return subgraphList;
}
public static <V, E> void assertEmbeddingEquals(PlanarGraph<V, E> graph, V vertex, String ids) {
String[] idArray = ids.split(",");
LinkedList<String> embeddingIds = new LinkedList<String>();
for (E edge : graph.edgesOf(vertex)) {
V other = Graphs.getOppositeVertex(graph, edge, vertex);
embeddingIds.add(other.toString());
}
if (idArray.length > 0) {
int firstIndex = embeddingIds.indexOf(idArray[0]);
if (firstIndex < 0) {
assertEquals(Arrays.deepToString(idArray), Arrays.deepToString(embeddingIds.toArray()));
} else {
Collections.rotate(embeddingIds, -firstIndex);
assertEquals(Arrays.deepToString(idArray), Arrays.deepToString(embeddingIds.toArray()));
}
} else {
assertEquals(Arrays.deepToString(idArray), Arrays.deepToString(embeddingIds.toArray()));
}
}
@Override
public boolean removeVertex(V vertex) {
return vertices.remove(vertex) && graph.removeVertex(vertex);
}
@Override
public boolean addVertex(V vertex) {
return graph.addVertex(vertex) && vertices.add(vertex);
}
@Override
public EdgeFactory<V, E> getEdgeFactory() {
return graph.getEdgeFactory();
}
@Override
public boolean containsEdge(E edge) {
return (vertices.contains(graph.getEdgeSource(edge))
&& vertices.contains(graph.getEdgeTarget(edge))
&& graph.containsEdge(edge));
}
@Override
public boolean containsEdge(V source, V target) {
return (vertices.contains(source)
&& vertices.contains(target)
&& graph.containsEdge(source, target));
}
@Override
public E removeEdge(V source, V target) {
E edge = getEdge(source, target);
if (edge != null) graph.removeEdge(source, target);
return edge;
}
@Override
public double getEdgeWeight(E edge) {
return containsEdge(edge) ? graph.getEdgeWeight(edge) : null;
}
@Override
public V getEdgeTarget(E edge) {
return containsEdge(edge) ? graph.getEdgeTarget(edge) : null;
}
@Override
public V getEdgeSource(E edge) {
return containsEdge(edge) ? graph.getEdgeSource(edge) : null;
}
@Override
public boolean removeEdge(E edge) {
return containsEdge(edge) && graph.removeEdge(edge);
}
