private List itemsTree(AbstractNode node) {
List valuesTreeForNode = new ArrayList();
for (Iterator i = node.getChildBoundables().iterator(); i.hasNext(); ) {
Boundable childBoundable = (Boundable) i.next();
if (childBoundable instanceof AbstractNode) {
List valuesTreeForChild = itemsTree((AbstractNode) childBoundable);
// only add if not null (which indicates an item somewhere in this tree
if (valuesTreeForChild != null) valuesTreeForNode.add(valuesTreeForChild);
} else if (childBoundable instanceof ItemBoundable) {
valuesTreeForNode.add(((ItemBoundable) childBoundable).getItem());
} else {
Assert.shouldNeverReachHere();
}
}
if (valuesTreeForNode.size() <= 0) return null;
return valuesTreeForNode;
}
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 query(Object searchBounds, AbstractNode node, List matches) {
List childBoundables = node.getChildBoundables();
for (int i = 0; i < childBoundables.size(); i++) {
Boundable childBoundable = (Boundable) childBoundables.get(i);
if (!getIntersectsOp().intersects(childBoundable.getBounds(), searchBounds)) {
continue;
}
if (childBoundable instanceof AbstractNode) {
query(searchBounds, (AbstractNode) childBoundable, matches);
} else if (childBoundable instanceof ItemBoundable) {
matches.add(((ItemBoundable) childBoundable).getItem());
} else {
Assert.shouldNeverReachHere();
}
}
}
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());
}
}