private int estimateLineString(LineString geom) {
if (geom == null || geom.getNumGeometries() == 0) {
return 0;
} else {
return 4
+ 8
* getCoordSequenceDim(geom.getCoordinateSequence())
* geom.getCoordinateSequence().size();
}
}
Map<String, Object> createLine(LineString line) {
LinkedHashMap obj = new LinkedHashMap();
obj.put("type", "LineString");
obj.put("coordinates", new CoordinateSequenceEncoder(line.getCoordinateSequence(), scale));
return obj;
}
/**
* Converts a JTS {@link Polygon}, which represents a ROI, int an AWT {@link java.awt.Polygon} by
* means of the provided {@link MathTransform}.
*
* <p>It also stores the points for this polygon into the provided {@link List}.
*
* @param roiInput the input ROI as a JTS {@link Polygon}.
* @param worldToGridTransform the {@link MathTransform} to apply to the input ROI.
* @param points a {@link List} that should hold the transformed points.
* @return an AWT {@link java.awt.Polygon}.
* @throws TransformException in case the provided {@link MathTransform} chokes.
*/
public static java.awt.Polygon convertPolygonToPointArray(
final Polygon roiInput, MathTransform worldToGridTransform, List<Point2D> points)
throws TransformException {
final boolean isIdentity = worldToGridTransform.isIdentity();
final double coords[] = new double[2];
final LineString exteriorRing = roiInput.getExteriorRing();
final CoordinateSequence exteriorRingCS = exteriorRing.getCoordinateSequence();
final int numCoords = exteriorRingCS.size();
final java.awt.Polygon retValue = new java.awt.Polygon();
for (int i = 0; i < numCoords; i++) {
// get the actual coord
coords[0] = exteriorRingCS.getX(i);
coords[1] = exteriorRingCS.getY(i);
// transform it
if (!isIdentity) worldToGridTransform.transform(coords, 0, coords, 0, 1);
// send it back to the returned polygon
final int x = (int) (coords[0] + 0.5d);
final int y = (int) (coords[1] + 0.5d);
if (points != null) points.add(new Point2D.Double(coords[0], coords[1]));
// send it back to the returned polygon
retValue.addPoint(x, y);
}
// return the created polygon.
return retValue;
}
/** decimates JTS geometries. */
public final Geometry decimate(Geometry geom) {
GeometryFactory gFac = new GeometryFactory(geom.getPrecisionModel(), geom.getSRID());
if (spanx == -1) return geom;
if (geom instanceof MultiPoint) {
// TODO check geometry and if its bbox is too small turn it into a 1
// point geom
return geom;
}
if (geom instanceof GeometryCollection) {
// TODO check geometry and if its bbox is too small turn it into a
// 1-2 point geom
// takes a bit of work because the geometry will need to be
// recreated.
GeometryCollection collection = (GeometryCollection) geom;
Geometry[] result = new Geometry[collection.getDimension()];
final int numGeometries = collection.getNumGeometries();
for (int i = 0; i < numGeometries; i++) {
result[i] = decimate(collection.getGeometryN(i));
}
return gFac.createGeometryCollection(result);
} else if (geom instanceof LineString) {
LineString line = (LineString) geom;
CoordinateSequence seq = (CoordinateSequence) line.getCoordinateSequence();
LiteCoordinateSequence lseq = new LiteCoordinateSequence(seq.toCoordinateArray());
if (decimateOnEnvelope(line, lseq)) {
if (lseq.size() >= 2) return gFac.createLineString(lseq);
}
if (lseq.size() >= 2) return gFac.createLineString(decimate(lseq));
return null;
} else if (geom instanceof Polygon) {
Polygon line = (Polygon) geom;
Coordinate[] exterior = decimate(line.getExteriorRing()).getCoordinates();
forceClosed(exterior);
if (exterior.length > 3) {
LinearRing ring = gFac.createLinearRing(exterior);
final int numRings = line.getNumInteriorRing();
List<LinearRing> rings = new ArrayList<LinearRing>();
for (int i = 0; i < numRings; i++) {
Coordinate[] interior = decimate(line.getInteriorRingN(i)).getCoordinates();
forceClosed(interior);
if (interior.length > 3) rings.add(gFac.createLinearRing(interior));
}
return gFac.createPolygon(ring, rings.toArray(new LinearRing[] {}));
}
return null;
}
return geom;
}
static DirectPosition[] positions(LineString line) {
CoordinateSequence coordinates = line.getCoordinateSequence();
DirectPosition[] dps = new DirectPosition[coordinates.size()];
double x;
double y;
for (int i = 0; i < dps.length; i++) {
x = coordinates.getOrdinate(i, 0);
y = coordinates.getOrdinate(i, 1);
dps[i] = new DirectPosition2D(x, y);
}
return dps;
}
public Geometry densify(double segLength) {
newCoords = new CoordinateList();
CoordinateSequence seq = inputLine.getCoordinateSequence();
Coordinate p0 = new Coordinate();
Coordinate p1 = new Coordinate();
seq.getCoordinate(0, p0);
newCoords.add(new Coordinate(p0));
for (int i = 0; i < seq.size() - 1; i++) {
seq.getCoordinate(i, p0);
seq.getCoordinate(i + 1, p1);
densify(p0, p1, segLength);
}
Coordinate[] newPts = newCoords.toCoordinateArray();
return inputLine.getFactory().createLineString(newPts);
}
/**
* @param ls
* @param at
* @param generalize
* @param maxDistance
* @return
*/
private void _init(LineString ls, AffineTransform at, boolean generalize, float maxDistance) {
if (at == null) {
at = NO_TRANSFORM;
}
this.at = at;
coordinates = ls.getCoordinateSequence();
coordinateCount = coordinates.size();
isClosed = ls instanceof LinearRing;
this.generalize = generalize;
this.maxDistance = maxDistance;
done = false;
currentCoord = 0;
oldX = Float.NaN;
oldY = Float.NaN;
}
private void writeLineString(LineString geom, ValueSetter dest) {
dest.setInt(geom.getNumPoints());
writeCoordinates(geom.getCoordinateSequence(), getCoordDim(geom), dest);
}
/**
* Transforms a {@link LineString} geometry.
*
* @param geom
* @param parent
* @return
*/
protected Geometry transformLineString(LineString geom, Geometry parent) {
// should check for 1-point sequences and downgrade them to points
return factory.createLineString(transformCoordinates(geom.getCoordinateSequence(), geom));
}