/**
* Because Delete Events have a link to their corresponding Insert event, it is possible to
* compute exactly the range of events which must be compared to a given Insert event object.
*/
private void prepareEvents() {
Collections.sort(events);
for (int i = 0; i < events.size(); i++) {
SweepLineEvent ev = (SweepLineEvent) events.get(i);
if (ev.isDelete()) {
ev.getInsertEvent().setDeleteEventIndex(i);
}
}
}
private void add(Edge edge, Object edgeSet) {
Coordinate[] pts = edge.getCoordinates();
for (int i = 0; i < pts.length - 1; i++) {
SweepLineSegment ss = new SweepLineSegment(edge, i);
SweepLineEvent insertEvent = new SweepLineEvent(edgeSet, ss.getMinX(), null, ss);
events.add(insertEvent);
events.add(new SweepLineEvent(edgeSet, ss.getMaxX(), insertEvent, ss));
}
}
private static Geometry convertSegStrings(Iterator it) {
GeometryFactory fact = new GeometryFactory();
List lines = new ArrayList();
while (it.hasNext()) {
SegmentString ss = (SegmentString) it.next();
LineString line = fact.createLineString(ss.getCoordinates());
lines.add(line);
}
return fact.buildGeometry(lines);
}
private void computeIntersections(SegmentIntersector si) {
nOverlaps = 0;
prepareEvents();
for (int i = 0; i < events.size(); i++) {
SweepLineEvent ev = (SweepLineEvent) events.get(i);
if (ev.isInsert()) {
processOverlaps(i, ev.getDeleteEventIndex(), ev, si);
}
}
}
public void findEdge(List dirEdgeList) {
/**
* Check all forward DirectedEdges only. This is still general, because each edge has a forward
* DirectedEdge.
*/
for (Iterator i = dirEdgeList.iterator(); i.hasNext(); ) {
DirectedEdge de = (DirectedEdge) i.next();
if (!de.isForward()) continue;
checkForRightmostCoordinate(de);
}
/**
* If the rightmost point is a node, we need to identify which of the incident edges is
* rightmost.
*/
Assert.isTrue(
minIndex != 0 || minCoord.equals(minDe.getCoordinate()),
"inconsistency in rightmost processing");
if (minIndex == 0) {
findRightmostEdgeAtNode();
} else {
findRightmostEdgeAtVertex();
}
/** now check that the extreme side is the R side. If not, use the sym instead. */
orientedDe = minDe;
int rightmostSide = getRightmostSide(minDe, minIndex);
if (rightmostSide == Position.LEFT) {
orientedDe = minDe.getSym();
}
}
private void add(List edges) {
for (Iterator i = edges.iterator(); i.hasNext(); ) {
Edge edge = (Edge) i.next();
// edge is its own group
add(edge, edge);
}
}
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;
}
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;
}
/**
* Completes the building of the input subgraphs by depth-labelling them, and adds them to the
* PolygonBuilder. The subgraph list must be sorted in rightmost-coordinate order.
*
* @param subgraphList the subgraphs to build
* @param polyBuilder the PolygonBuilder which will build the final polygons
*/
private void buildSubgraphs(List subgraphList, PolygonBuilder polyBuilder) {
List processedGraphs = new ArrayList();
for (Iterator i = subgraphList.iterator(); i.hasNext(); ) {
BufferSubgraph subgraph = (BufferSubgraph) i.next();
Coordinate p = subgraph.getRightmostCoordinate();
// int outsideDepth = 0;
// if (polyBuilder.containsPoint(p))
// outsideDepth = 1;
SubgraphDepthLocater locater = new SubgraphDepthLocater(processedGraphs);
int outsideDepth = locater.getDepth(p);
// try {
subgraph.computeDepth(outsideDepth);
// }
// catch (RuntimeException ex) {
// // debugging only
// //subgraph.saveDirEdges();
// throw ex;
// }
subgraph.findResultEdges();
processedGraphs.add(subgraph);
polyBuilder.add(subgraph.getDirectedEdges(), subgraph.getNodes());
}
}
private void processOverlaps(int start, int end, SweepLineEvent ev0, SegmentIntersector si) {
SweepLineSegment ss0 = (SweepLineSegment) ev0.getObject();
/**
* Since we might need to test for self-intersections, include current insert event object in
* list of event objects to test. Last index can be skipped, because it must be a Delete event.
*/
for (int i = start; i < end; i++) {
SweepLineEvent ev1 = (SweepLineEvent) events.get(i);
if (ev1.isInsert()) {
SweepLineSegment ss1 = (SweepLineSegment) ev1.getObject();
if (ev0.edgeSet == null || (ev0.edgeSet != ev1.edgeSet)) {
ss0.computeIntersections(ss1, si);
nOverlaps++;
}
}
}
}
private void add(List edges, Object edgeSet) {
for (Iterator i = edges.iterator(); i.hasNext(); ) {
Edge edge = (Edge) i.next();
add(edge, edgeSet);
}
}