protected Geometry transformPolygon(Polygon geom, Geometry parent) {
boolean isAllValidLinearRings = true;
Geometry shell = transformLinearRing((LinearRing) geom.getExteriorRing(), geom);
if (shell == null || !(shell instanceof LinearRing) || shell.isEmpty())
isAllValidLinearRings = false;
// return factory.createPolygon(null, null);
ArrayList holes = new ArrayList();
for (int i = 0; i < geom.getNumInteriorRing(); i++) {
Geometry hole = transformLinearRing((LinearRing) geom.getInteriorRingN(i), geom);
if (hole == null || hole.isEmpty()) {
continue;
}
if (!(hole instanceof LinearRing)) isAllValidLinearRings = false;
holes.add(hole);
}
if (isAllValidLinearRings)
return factory.createPolygon(
(LinearRing) shell, (LinearRing[]) holes.toArray(new LinearRing[] {}));
else {
List components = new ArrayList();
if (shell != null) components.add(shell);
components.addAll(holes);
return factory.buildGeometry(components);
}
}
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);
}
protected Geometry transformMultiPolygon(MultiPolygon geom, Geometry parent) {
List transGeomList = new ArrayList();
for (int i = 0; i < geom.getNumGeometries(); i++) {
Geometry transformGeom = transformPolygon((Polygon) geom.getGeometryN(i), geom);
if (transformGeom == null) continue;
if (transformGeom.isEmpty()) continue;
transGeomList.add(transformGeom);
}
return factory.buildGeometry(transGeomList);
}
private Geobuf.Data.Feature makeFeature(GeobufFeature feature, List<String> keys) {
Geobuf.Data.Feature.Builder feat =
Geobuf.Data.Feature.newBuilder().setGeometry(geomToGeobuf(feature.geometry));
for (Map.Entry<String, Object> e : feature.properties.entrySet()) {
// TODO store keys separately from features
Geobuf.Data.Value.Builder val = Geobuf.Data.Value.newBuilder();
Object featVal = e.getValue();
if (featVal instanceof String) val.setStringValue((String) featVal);
else if (featVal instanceof Boolean) val.setBoolValue((Boolean) featVal);
else if (featVal instanceof Integer) {
int keyInt = (Integer) featVal;
if (keyInt >= 0) val.setPosIntValue(keyInt);
else val.setNegIntValue(keyInt);
} else if (featVal instanceof Long) {
long keyLong = (Long) featVal;
if (keyLong >= 0) val.setPosIntValue(keyLong);
else val.setNegIntValue(keyLong);
} else if (featVal instanceof Double || featVal instanceof Float)
val.setDoubleValue(((Number) featVal).doubleValue());
else {
// TODO serialize to JSON
LOG.warn(
"Unable to save object of type {} to geobuf, falling back on toString. Deserialization will not work as expected.",
featVal.getClass());
val.setStringValue(featVal.toString());
}
int keyIdx = keys.indexOf(e.getKey());
if (keyIdx == -1) {
synchronized (keys) {
keyIdx = keys.size();
keys.add(e.getKey());
}
}
// properties is a jagged array of [key index, value index, . . .]
feat.addProperties(keyIdx);
feat.addProperties(feat.getValuesCount());
feat.addValues(val);
}
if (feature.id != null) {
feat.setId(feature.id);
feat.clearIntId();
} else {
feat.setIntId(feature.numericId);
feat.clearId();
}
return feat.build();
}
protected Geometry transformGeometryCollection(GeometryCollection geom, Geometry parent) {
List transGeomList = new ArrayList();
for (int i = 0; i < geom.getNumGeometries(); i++) {
Geometry transformGeom = transform(geom.getGeometryN(i));
if (transformGeom == null) continue;
if (pruneEmptyGeometry && transformGeom.isEmpty()) continue;
transGeomList.add(transformGeom);
}
if (preserveGeometryCollectionType)
return factory.createGeometryCollection(GeometryFactory.toGeometryArray(transGeomList));
return factory.buildGeometry(transGeomList);
}
/**
* Computes the list of envelopes (from 2 to 4, possibily 0 if env covers this) resulting from the
* extrusion of env from this. Only in 2D for the moment. Does not return null envelopes.
*/
public List<Envelope> extrusion(final Envelope env) {
List<Envelope> list = new ArrayList();
double x1 = getMinX();
double x2 = getMaxX();
double y1 = getMinY();
double y2 = getMaxY();
double xx1 = env.getMinX();
double xx2 = env.getMaxX();
double yy1 = env.getMinY();
double yy2 = env.getMaxY();
if (x2 >= x1 && yy1 >= y1) {
list.add(new Envelope(x1, x2, y1, yy1));
}
if (xx1 >= x1 && y2 >= yy1) {
list.add(new Envelope(x1, xx1, yy1, y2));
}
if (x2 >= xx1 && y2 >= yy2) {
list.add(new Envelope(xx1, x2, yy2, y2));
}
if (x2 >= xx2 && yy2 >= yy1) {
list.add(new Envelope(xx2, x2, yy1, yy2));
}
return list;
}
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());
}
}
/**
* This method is called by clients of the {@link SegmentIntersector} class to process
* intersections for two segments of the {@link SegmentString}s being intersected. Note that some
* clients (such as {@link MonotoneChain}s) may optimize away this call for segment pairs which
* they have determined do not intersect (e.g. by an disjoint envelope test).
*/
public void processIntersections(
SegmentString e0, int segIndex0, SegmentString e1, int segIndex1) {
// don't bother intersecting a segment with itself
if (e0 == e1 && segIndex0 == segIndex1) return;
Coordinate p00 = e0.getCoordinates()[segIndex0];
Coordinate p01 = e0.getCoordinates()[segIndex0 + 1];
Coordinate p10 = e1.getCoordinates()[segIndex1];
Coordinate p11 = e1.getCoordinates()[segIndex1 + 1];
li.computeIntersection(p00, p01, p10, p11);
// if (li.hasIntersection() && li.isProper()) Debug.println(li);
if (li.hasIntersection()) {
if (li.isInteriorIntersection()) {
for (int intIndex = 0; intIndex < li.getIntersectionNum(); intIndex++) {
interiorIntersections.add(li.getIntersection(intIndex));
}
((NodedSegmentString) e0).addIntersections(li, segIndex0, 0);
((NodedSegmentString) e1).addIntersections(li, segIndex1, 1);
}
}
}
public void addToResult(LineSegment seg) {
resultSegs.add(seg);
}
/**
* Adds a hole to the polygon formed by this ring.
*
* @param hole the {@link LinearRing} forming the hole.
*/
public void addHole(LinearRing hole) {
if (holes == null) holes = new ArrayList();
holes.add(hole);
}
/**
* Adds a {@link DirectedEdge} which is known to form part of this ring.
*
* @param de the {@link DirectedEdge} to add.
*/
public void add(DirectedEdge de) {
deList.add(de);
}