/**
* Inserted edges are checked to see if an identical edge already exists. If so, the edge is not
* inserted, but its label is merged with the existing edge.
*/
protected void insertUniqueEdge(Edge e) {
// <FIX> MD 8 Oct 03 speed up identical edge lookup
// fast lookup
Edge existingEdge = edgeList.findEqualEdge(e);
// If an identical edge already exists, simply update its label
if (existingEdge != null) {
Label existingLabel = existingEdge.getLabel();
Label labelToMerge = e.getLabel();
// check if new edge is in reverse direction to existing edge
// if so, must flip the label before merging it
if (!existingEdge.isPointwiseEqual(e)) {
labelToMerge = new Label(e.getLabel());
labelToMerge.flip();
}
existingLabel.merge(labelToMerge);
// compute new depth delta of sum of edges
int mergeDelta = depthDelta(labelToMerge);
int existingDelta = existingEdge.getDepthDelta();
int newDelta = existingDelta + mergeDelta;
existingEdge.setDepthDelta(newDelta);
} else { // no matching existing edge was found
// add this new edge to the list of edges in this graph
// e.setName(name + edges.size());
edgeList.add(e);
e.setDepthDelta(depthDelta(e.getLabel()));
}
}
void addNode(Node node) {
setNodeReachable(node);
EdgeList list = node.incoming;
Edge e;
for (int i = 0; i < list.size(); i++) {
e = list.getEdge(i);
if (!isNodeReachable(e.source)) {
if (!isCandidate(e)) {
setCandidate(e);
candidates.add(e);
}
} else candidates.remove(e);
}
list = node.outgoing;
for (int i = 0; i < list.size(); i++) {
e = list.getEdge(i);
if (!isNodeReachable(e.target)) {
if (!isCandidate(e)) {
setCandidate(e);
candidates.add(e);
}
} else candidates.remove(e);
}
members.add(node);
}
/**
* The kruskal static method runs the Kruskal algorithm given an EdgeList. This in effect returns
* the minimum spanning tree of a graph (MST).
*
* @param edgeList -The collection of edges for a graph.
* @return -The Collection representing the minimum spanning tree.
*/
public static Collection<Edge> kruskal(EdgeList edgeList) {
ArrayList<Edge> mST = new ArrayList<Edge>();
UnionFind dataStruct = new UnionFind(edgeList);
PriorityQueue<Edge> edges = edgeList.getEdges();
while (!edges.isEmpty()) {
Edge minEdge = edges.poll();
boolean condition = dataStruct.sameComponent(minEdge.getU(), minEdge.getV());
if (condition == false) {
dataStruct.union(minEdge.getU(), minEdge.getV());
mST.add(minEdge);
}
}
return mST;
}
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 void fortunesAlgorithm() {
Site newSite, bottomSite, topSite, tempSite;
Vertex v, vertex;
Point newintstar = null;
LR leftRight;
Halfedge lbnd, rbnd, llbnd, rrbnd, bisector;
Edge edge;
Rectangle dataBounds = _sites.getSitesBounds();
int sqrt_nsites = (int) Math.sqrt(_sites.get_length() + 4);
HalfedgePriorityQueue heap =
new HalfedgePriorityQueue(dataBounds.y, dataBounds.height, sqrt_nsites);
EdgeList edgeList = new EdgeList(dataBounds.x, dataBounds.width, sqrt_nsites);
ArrayList<Halfedge> halfEdges = new ArrayList();
ArrayList<Vertex> vertices = new ArrayList();
Site bottomMostSite = _sites.next();
newSite = _sites.next();
for (; ; ) {
if (heap.empty() == false) {
newintstar = heap.min();
}
if (newSite != null && (heap.empty() || compareByYThenX(newSite, newintstar) < 0)) {
/* new site is smallest */
// trace("smallest: new site " + newSite);
// Step 8:
lbnd =
edgeList.edgeListLeftNeighbor(
newSite.get_coord()); // the Halfedge just to the left of newSite
// trace("lbnd: " + lbnd);
rbnd = lbnd.edgeListRightNeighbor; // the Halfedge just to the right
// trace("rbnd: " + rbnd);
bottomSite = rightRegion(lbnd, bottomMostSite); // this is the same as leftRegion(rbnd)
// this Site determines the region containing the new site
// trace("new Site is in region of existing site: " + bottomSite);
// Step 9:
edge = Edge.createBisectingEdge(bottomSite, newSite);
// trace("new edge: " + edge);
_edges.add(edge);
bisector = Halfedge.create(edge, LR.LEFT);
halfEdges.add(bisector);
// inserting two Halfedges into edgeList constitutes Step 10:
// insert bisector to the right of lbnd:
edgeList.insert(lbnd, bisector);
// first half of Step 11:
if ((vertex = Vertex.intersect(lbnd, bisector)) != null) {
vertices.add(vertex);
heap.remove(lbnd);
lbnd.vertex = vertex;
lbnd.ystar = vertex.get_y() + newSite.dist(vertex);
heap.insert(lbnd);
}
lbnd = bisector;
bisector = Halfedge.create(edge, LR.RIGHT);
halfEdges.add(bisector);
// second Halfedge for Step 10:
// insert bisector to the right of lbnd:
edgeList.insert(lbnd, bisector);
// second half of Step 11:
if ((vertex = Vertex.intersect(bisector, rbnd)) != null) {
vertices.add(vertex);
bisector.vertex = vertex;
bisector.ystar = vertex.get_y() + newSite.dist(vertex);
heap.insert(bisector);
}
newSite = _sites.next();
} else if (heap.empty() == false) {
/* intersection is smallest */
lbnd = heap.extractMin();
llbnd = lbnd.edgeListLeftNeighbor;
rbnd = lbnd.edgeListRightNeighbor;
rrbnd = rbnd.edgeListRightNeighbor;
bottomSite = leftRegion(lbnd, bottomMostSite);
topSite = rightRegion(rbnd, bottomMostSite);
// these three sites define a Delaunay triangle
// (not actually using these for anything...)
// _triangles.push(new Triangle(bottomSite, topSite, rightRegion(lbnd)));
v = lbnd.vertex;
v.setIndex();
lbnd.edge.setVertex(lbnd.leftRight, v);
rbnd.edge.setVertex(rbnd.leftRight, v);
edgeList.remove(lbnd);
heap.remove(rbnd);
edgeList.remove(rbnd);
leftRight = LR.LEFT;
if (bottomSite.get_y() > topSite.get_y()) {
tempSite = bottomSite;
bottomSite = topSite;
topSite = tempSite;
leftRight = LR.RIGHT;
}
edge = Edge.createBisectingEdge(bottomSite, topSite);
_edges.add(edge);
bisector = Halfedge.create(edge, leftRight);
halfEdges.add(bisector);
edgeList.insert(llbnd, bisector);
edge.setVertex(LR.other(leftRight), v);
if ((vertex = Vertex.intersect(llbnd, bisector)) != null) {
vertices.add(vertex);
heap.remove(llbnd);
llbnd.vertex = vertex;
llbnd.ystar = vertex.get_y() + bottomSite.dist(vertex);
heap.insert(llbnd);
}
if ((vertex = Vertex.intersect(bisector, rrbnd)) != null) {
vertices.add(vertex);
bisector.vertex = vertex;
bisector.ystar = vertex.get_y() + bottomSite.dist(vertex);
heap.insert(bisector);
}
} else {
break;
}
}
// heap should be empty now
heap.dispose();
edgeList.dispose();
for (Halfedge halfEdge : halfEdges) {
halfEdge.reallyDispose();
}
halfEdges.clear();
// we need the vertices to clip the edges
for (Edge e : _edges) {
e.clipVertices(_plotBounds);
}
// but we don't actually ever use them again!
for (Vertex v0 : vertices) {
v0.dispose();
}
vertices.clear();
}
