public int getLength(Object geometry) {
MultiLineString multi = (MultiLineString) geometry;
int numlines;
int numpoints;
int length;
numlines = multi.getNumGeometries();
numpoints = multi.getNumPoints();
if (shapeType == ShapeType.ARC) {
length = 44 + (4 * numlines) + (numpoints * 16);
} else if (shapeType == ShapeType.ARCM) {
length = 44 + (4 * numlines) + (numpoints * 16) + 8 + 8 + (8 * numpoints);
} else if (shapeType == ShapeType.ARCZ) {
length =
44
+ (4 * numlines)
+ (numpoints * 16)
+ 8
+ 8
+ (8 * numpoints)
+ 8
+ 8
+ (8 * numpoints);
} else {
throw new IllegalStateException("Expected ShapeType of Arc, got " + shapeType);
}
return length;
}
/**
* Returns a completed multi type.
*
* @param geometryFactory The factory this method should use to create the multi type.
* @return Appropriate multi geometry type.
*/
public Geometry create(GeometryFactory geometryFactory) {
if (internalType.equals("Point")) {
Point[] pointArray = geometryFactory.toPointArray(geometries);
MultiPoint multiPoint = geometryFactory.createMultiPoint(pointArray);
multiPoint.setUserData(getSRS());
multiPoint.setSRID(getSRID());
LOGGER.fine("created " + multiPoint);
return multiPoint;
} else if (internalType.equals("LineString")) {
LineString[] lineStringArray = geometryFactory.toLineStringArray(geometries);
MultiLineString multiLineString = geometryFactory.createMultiLineString(lineStringArray);
multiLineString.setUserData(getSRS());
multiLineString.setSRID(getSRID());
LOGGER.fine("created " + multiLineString);
return multiLineString;
} else if (internalType.equals("Polygon")) {
Polygon[] polygonArray = geometryFactory.toPolygonArray(geometries);
MultiPolygon multiPolygon = geometryFactory.createMultiPolygon(polygonArray);
multiPolygon.setUserData(getSRS());
multiPolygon.setSRID(getSRID());
LOGGER.fine("created " + multiPolygon);
return multiPolygon;
} else {
return null;
}
}
public void test() throws Exception {
Node node =
createNode(
ml,
new ElementInstance[] {line1, line2},
new Object[] {
new GeometryFactory()
.createLineString(new Coordinate[] {new Coordinate(0, 0), new Coordinate(1, 1)}),
new GeometryFactory()
.createLineString(new Coordinate[] {new Coordinate(2, 2), new Coordinate(3, 3)})
},
null,
null);
GMLGeometryCollectionTypeBinding s1 =
(GMLGeometryCollectionTypeBinding)
container.getComponentInstanceOfType(GMLGeometryCollectionTypeBinding.class);
GMLMultiLineStringTypeBinding s2 =
(GMLMultiLineStringTypeBinding)
container.getComponentInstanceOfType(GMLMultiLineStringTypeBinding.class);
MultiLineString mline = (MultiLineString) s2.parse(ml, node, s1.parse(ml, node, null));
assertNotNull(mline);
assertEquals(mline.getNumGeometries(), 2);
}
@Override
public MultiLineString apply(LineString object) throws UnconvertibleObjectException {
final MultiLineString geom =
object.getFactory().createMultiLineString(new LineString[] {object});
geom.setSRID(object.getSRID());
geom.setUserData(object.getUserData());
return geom;
}
protected Geometry transformMultiLineString(MultiLineString geom, Geometry parent) {
List transGeomList = new ArrayList();
for (int i = 0; i < geom.getNumGeometries(); i++) {
Geometry transformGeom = transformLineString((LineString) geom.getGeometryN(i), geom);
if (transformGeom == null) continue;
if (transformGeom.isEmpty()) continue;
transGeomList.add(transformGeom);
}
return factory.buildGeometry(transGeomList);
}
protected static Geometry transformMultiLineString(
CoordinateTransform ct, MultiLineString multiLineString) {
LineString[] lineString = new LineString[multiLineString.getNumGeometries()];
for (int i = 0; i < lineString.length; ++i) {
lineString[i] =
multiLineString
.getFactory()
.createLineString(
transformCoordinates(ct, multiLineString.getGeometryN(i).getCoordinates()));
}
return multiLineString.getFactory().createMultiLineString(lineString);
}
public ShapeElemtex(SimpleFeature f, String tipo) {
super(f, tipo);
shapeId = "ELEMTEX" + super.newShapeId();
// Elemtex trae la geometria en formato MultiLineString
if (f.getDefaultGeometry()
.getClass()
.getName()
.equals("com.vividsolutions.jts.geom.MultiLineString")) {
MultiLineString l = (MultiLineString) f.getDefaultGeometry();
LineString line = new LineString(l.getCoordinates(), null, 0);
coor = line.getEnvelopeInternal().centre();
} else {
System.out.println(
"["
+ new Timestamp(new Date().getTime())
+ "] Formato geometrico "
+ f.getDefaultGeometry().getClass().getName()
+ " desconocido dentro del shapefile ELEMTEX");
}
// Los demas atributos son metadatos y de ellos sacamos
ttggss = (String) f.getAttribute("TTGGSS");
// try {
// rotulo = new String(f.getAttribute("ROTULO").toString().getBytes(), "UTF-8");
// rotulo = eliminarComillas(rotulo);
// } catch (UnsupportedEncodingException e) {e.printStackTrace();}
rotulo = eliminarComillas(f.getAttribute("ROTULO").toString());
// Dependiendo del ttggss se usa o no
if (ttggss != null) {
tags.addAll(ttggssParser(ttggss));
}
// Si queremos coger todos los atributos del .shp
// this.atributos = new ArrayList<ShapeAttribute>();
// for (int x = 1; x < f.getAttributes().size(); x++){
// atributos.add(new ShapeAttribute(f.getFeatureType().getDescriptor(x).getType(),
// f.getAttributes().get(x)));
// }
}
private String transformMultiLineStringToJsonLineStringArray(MultiLineString multilinestring) {
LOGGER.info("Transforming multilinestring to JSON linestring array");
/*
* For a multi line, we make several simple lines and put them into an array
*/
String lineArray = "[";
boolean firstElement = true;
for (int i = 0; i < multilinestring.getNumGeometries(); i++) {
LineString linestring = (LineString) multilinestring.getGeometryN(i);
String aLine = transformLineStringToJsonLineString(linestring);
if (firstElement) {
lineArray = lineArray.concat(aLine);
firstElement = false;
} else {
lineArray = lineArray.concat(", " + aLine);
}
}
return lineArray;
}
// Multilinestring
private String transformMultiLineStringToJsonLineString(MultiLineString multilinestring) {
LOGGER.info("Transforming multilinestring to JSON linestring with several paths in it.");
/* Lines are like this: {"paths":[[[-122.68,45.53], [-122.58,45.55],[-122.57,45.58],[-122.53,45.6]]],
"spatialReference":{"wkid":4326}}
* For a multi line, we put several paths.
* We will assemble it in several parts:
* (a) {"paths":[
* (b) several paths, comma separated, each has square brackets:
* (b) [ [coords],[coords],[coords] ] <== this is one path, with square brackets!
* (b) [ [coords],[coords],[coords] ], <== this is one path, with square brackets!
* (b) [ [coords],[coords],[coords] ], <== this is one path, with square brackets!
* (c) ],
* (d) "spatialReference":{"wkid":4326}
* (e) }
*/
// (1) make paths, and concatenate them, comma separated
String allPaths = "";
boolean firstElement = true;
for (int i = 0; i < multilinestring.getNumGeometries(); i++) {
LineString linestring = (LineString) multilinestring.getGeometryN(i);
String aPath = linestringToJsonPath(linestring);
if (firstElement) {
allPaths = allPaths.concat(aPath);
firstElement = false;
} else {
allPaths = allPaths.concat(", " + aPath);
}
}
// (2) assemble to line
String jsonString = assembleLine(allPaths, multilinestring);
return jsonString;
}
/**
* Transform a feature to a JSON string
*
* <p>The feature that is passed to this method is transformed to a JSON string according to this
* site (http://help.arcgis.com/en/webapi/javascript/arcgis/help/jsapi_start.htm).
*
* @param geom
* @return
* @throws IOException
*/
private String transformOneFeature(Geometry geom) throws IOException {
// Depending on geometry's type, transform to json geometry
String jsonString = "";
// simple geometries:
if (geom instanceof Point) {
jsonString = transformPointToJsonPoint((Point) geom);
} else if (geom instanceof LineString) {
jsonString = transformLineStringToJsonLineString((LineString) geom);
} else if (geom instanceof Polygon) {
jsonString = transformPolygonToJsonPolygon((Polygon) geom);
}
// multipoint
else if (geom instanceof MultiPoint) {
MultiPoint multipoint = (MultiPoint) geom;
// if only one point inside, make normal point out of it
if (multipoint.getNumGeometries() == 1) {
Point point = (Point) multipoint.getGeometryN(0);
jsonString = transformPointToJsonPoint(point);
} else {
jsonString = transformMultiPointToJsonMultiPoint(multipoint);
}
// multilinestring
} else if (geom instanceof MultiLineString) {
MultiLineString multiline = (MultiLineString) geom;
// if only one linestring inside, make normal linestring out of it
if (multiline.getNumGeometries() == 1) {
LineString line = (LineString) multiline.getGeometryN(0);
jsonString = transformLineStringToJsonLineString(line);
}
// real multilinestring
else {
if (multiGeometriesToArray) {
jsonString = transformMultiLineStringToJsonLineStringArray(multiline);
} else {
jsonString = transformMultiLineStringToJsonLineString(multiline);
}
}
// multipolygon
} else if (geom instanceof MultiPolygon) {
MultiPolygon multipoly = (MultiPolygon) geom;
// if only one polygon inside, make normal polygon out of it
if (multipoly.getNumGeometries() == 1) {
Polygon poly = (Polygon) multipoly.getGeometryN(0);
jsonString = transformPolygonToJsonPolygon(poly);
}
// real multi polygon
else {
if (multiGeometriesToArray) {
jsonString = transformMultiPolygonToJsonPolygonArray(multipoly);
} else {
jsonString = transformMultiPolygonToJsonPolygon(multipoly);
}
}
} else {
LOGGER.error("Feature has no recognized geometry type");
}
return jsonString;
}
public static IGlobeFeatureCollection<
IVector2, ? extends IBoundedGeometry2D<? extends IFinite2DBounds<?>>>
readFeatures(final DataStore dataStore, final String layerName, final GProjection projection)
throws Exception {
final SimpleFeatureSource featureSource = dataStore.getFeatureSource(layerName);
final SimpleFeatureCollection featuresCollection = featureSource.getFeatures();
final GIntHolder validCounter = new GIntHolder(0);
// final GIntHolder polygonsWithHolesCounter = new GIntHolder(0);
final GIntHolder invalidCounter = new GIntHolder(0);
// final GIntHolder validVerticesCounter = new GIntHolder(0);
final GIntHolder polygonsCounter = new GIntHolder(0);
final GIntHolder linesCounter = new GIntHolder(0);
final GIntHolder pointsCounter = new GIntHolder(0);
final int featuresCount = featuresCollection.size();
final ArrayList<IGlobeFeature<IVector2, IBoundedGeometry2D<? extends IFinite2DBounds<?>>>>
euclidFeatures =
new ArrayList<
IGlobeFeature<IVector2, IBoundedGeometry2D<? extends IFinite2DBounds<?>>>>(
featuresCount);
final GProgress progress =
new GProgress(featuresCount) {
@Override
public void informProgress(
final double percent, final long elapsed, final long estimatedMsToFinish) {
// System.out.println("Loading \"" + fileName.buildPath() + "\" "
// + progressString(percent, elapsed,
// estimatedMsToFinish));
System.out.println(
"Loading data from data storage: "
+ layerName
+ " "
+ progressString(percent, elapsed, estimatedMsToFinish));
}
};
final FeatureIterator<SimpleFeature> iterator = featuresCollection.features();
while (iterator.hasNext()) {
final SimpleFeature feature = iterator.next();
final GeometryAttribute geometryAttribute = feature.getDefaultGeometryProperty();
final GeometryType type = geometryAttribute.getType();
if (type.getBinding() == com.vividsolutions.jts.geom.MultiPolygon.class) {
polygonsCounter.increment();
final com.vividsolutions.jts.geom.MultiPolygon multipolygon =
(com.vividsolutions.jts.geom.MultiPolygon) geometryAttribute.getValue();
final int geometriesCount = multipolygon.getNumGeometries();
final List<IPolygon2D> polygons = new ArrayList<IPolygon2D>(geometriesCount);
for (int i = 0; i < geometriesCount; i++) {
final com.vividsolutions.jts.geom.Polygon jtsPolygon =
(com.vividsolutions.jts.geom.Polygon) multipolygon.getGeometryN(i);
try {
final IPolygon2D euclidPolygon = createEuclidPolygon(projection, jtsPolygon);
if (euclidPolygon != null) {
// euclidFeatures.add(createFeature(euclidPolygon, feature));
polygons.add(euclidPolygon);
validCounter.increment();
}
} catch (final IllegalArgumentException e) {
// System.err.println(e.getMessage());
}
}
if (!polygons.isEmpty()) {
if (polygons.size() == 1) {
euclidFeatures.add(createFeature(polygons.get(0), feature));
} else {
euclidFeatures.add(createFeature(new GMultiGeometry2D<IPolygon2D>(polygons), feature));
}
}
} else if (type.getBinding() == com.vividsolutions.jts.geom.MultiLineString.class) {
linesCounter.increment();
final com.vividsolutions.jts.geom.MultiLineString multiline =
(com.vividsolutions.jts.geom.MultiLineString) geometryAttribute.getValue();
final int geometriesCount = multiline.getNumGeometries();
final List<IPolygonalChain2D> lines = new ArrayList<IPolygonalChain2D>(geometriesCount);
for (int i = 0; i < geometriesCount; i++) {
final com.vividsolutions.jts.geom.LineString jtsLine =
(com.vividsolutions.jts.geom.LineString) multiline.getGeometryN(i);
try {
final IPolygonalChain2D euclidLine = createLine(jtsLine.getCoordinates(), projection);
// euclidFeatures.add(createFeature(euclidLines, feature));
lines.add(euclidLine);
} catch (final IllegalArgumentException e) {
// System.err.println(e.getMessage());
}
}
if (!lines.isEmpty()) {
if (lines.size() == 1) {
euclidFeatures.add(createFeature(lines.get(0), feature));
} else {
euclidFeatures.add(
createFeature(new GMultiGeometry2D<IPolygonalChain2D>(lines), feature));
}
}
validCounter.increment();
} else if (type.getBinding() == com.vividsolutions.jts.geom.Point.class) {
pointsCounter.increment();
final IVector2 euclidPoint =
createPoint(
((com.vividsolutions.jts.geom.Point) geometryAttribute.getValue()).getCoordinate(),
projection);
euclidFeatures.add(createFeature(euclidPoint, feature));
validCounter.increment();
} else if (type.getBinding() == com.vividsolutions.jts.geom.MultiPoint.class) {
final IBoundedGeometry2D<? extends IFinite2DBounds<?>> euclidMultipoint =
createEuclidMultiPoint(geometryAttribute, projection);
euclidFeatures.add(createFeature(euclidMultipoint, feature));
validCounter.increment();
} else {
invalidCounter.increment();
System.out.println("invalid type: " + type);
}
progress.stepDone();
}
dataStore.dispose();
euclidFeatures.trimToSize();
System.out.println();
System.out.println("Features: " + featuresCount);
System.out.println();
System.out.println("Read " + validCounter.get() + " valid geometries");
System.out.println(" => " + polygonsCounter.get() + " valid polygons");
System.out.println(" => " + linesCounter.get() + " valid lines");
System.out.println(" => " + pointsCounter.get() + " valid points");
System.out.println();
if (invalidCounter.get() > 0) {
System.out.println("Ignored " + invalidCounter.get() + " invalid geometries");
}
System.out.println();
final SimpleFeatureType schema = featureSource.getSchema();
final int fieldsCount = schema.getAttributeCount();
final List<GField> fields = new ArrayList<GField>(fieldsCount);
System.out.println("Fields count: " + fieldsCount);
for (int i = 0; i < fieldsCount; i++) {
final String fieldName = schema.getType(i).getName().getLocalPart();
System.out.println("Fieldname: " + fieldName);
final Class<?> fieldType = schema.getType(i).getBinding();
fields.add(new GField(fieldName, fieldType));
}
return new GListFeatureCollection<IVector2, IBoundedGeometry2D<? extends IFinite2DBounds<?>>>(
GProjection.EPSG_4326, fields, euclidFeatures, "uniqueId_000");
}
/**
* Return an image of the world with a shape drawn on it. Flags control the rendering mode.
* Default is a hollow shape in red outline, touching the borders of the image.
*
* @param shape
* @param width
* @param height
* @param flags
* @return
* @throws ThinklabException
*/
public BufferedImage getImagery(
Envelope envelope, ShapeValue shape, int width, int height, int flags)
throws ThinklabException {
BufferedImage ret = getImagery(envelope, width, height);
GeometryFactory geoFactory = new GeometryFactory();
double edgeBuffer = 0.0;
if (ret == null) {
ret =
getSatelliteImage(
envelope, width, height, null, null, HAlignment.MIDDLE, VAlignment.MIDDLE);
}
/*
* draw shape boundaries.
*/
Geometry geometry = shape.getGeometry();
double x = envelope.getMinX() - edgeBuffer;
double y = envelope.getMinY() - edgeBuffer;
double w = envelope.getWidth() + edgeBuffer * 2;
double h = envelope.getHeight() + edgeBuffer * 2;
java.awt.geom.Rectangle2D.Double bounds = new java.awt.geom.Rectangle2D.Double(x, y, w, h);
Graphics graphics = ret.getGraphics();
if ((flags & GREEN_SHAPES) != 0) {
graphics.setColor(Color.green);
} else {
graphics.setColor(Color.red);
}
graphics.setPaintMode();
if (geometry.getClass().equals(MultiPolygon.class)
|| geometry.getClass().equals(Polygon.class)) {
for (int i = 0; i < geometry.getNumGeometries(); i++) {
com.vividsolutions.jts.geom.Polygon poly =
(com.vividsolutions.jts.geom.Polygon) geometry.getGeometryN(i);
LinearRing lr = geoFactory.createLinearRing(poly.getExteriorRing().getCoordinates());
com.vividsolutions.jts.geom.Polygon part = geoFactory.createPolygon(lr, null);
drawGeometry(part, bounds, graphics, width, height, flags);
for (int j = 0; j < poly.getNumInteriorRing(); j++) {
lr = geoFactory.createLinearRing(poly.getInteriorRingN(j).getCoordinates());
part = geoFactory.createPolygon(lr, null);
drawGeometry(part, bounds, graphics, width, height, flags);
}
}
} else if (geometry.getClass().equals(MultiLineString.class)) {
MultiLineString mp = (MultiLineString) geometry;
for (int n = 0; n < mp.getNumGeometries(); n++) {
drawGeometry(mp.getGeometryN(n), bounds, graphics, width, height, flags);
}
} else if (geometry.getClass().equals(MultiPoint.class)) {
MultiPoint mp = (MultiPoint) geometry;
for (int n = 0; n < mp.getNumGeometries(); n++) {
drawGeometry(mp.getGeometryN(n), bounds, graphics, width, height, flags);
}
} else {
drawGeometry(geometry, bounds, graphics, width, height, flags);
}
return ret;
}
public void write(WriteBufferManager buffer, Object geometry) throws IOException {
MultiLineString multi = (MultiLineString) geometry;
Envelope box = multi.getEnvelopeInternal();
buffer.putDouble(box.getMinX());
buffer.putDouble(box.getMinY());
buffer.putDouble(box.getMaxX());
buffer.putDouble(box.getMaxY());
int numParts = multi.getNumGeometries();
buffer.putInt(numParts);
int npoints = multi.getNumPoints();
buffer.putInt(npoints);
LineString[] lines = new LineString[numParts];
int idx = 0;
for (int i = 0; i < numParts; i++) {
lines[i] = (LineString) multi.getGeometryN(i);
buffer.putInt(idx);
idx = idx + lines[i].getNumPoints();
}
Coordinate[] coords = multi.getCoordinates();
for (int t = 0; t < npoints; t++) {
buffer.putDouble(coords[t].x);
buffer.putDouble(coords[t].y);
}
if (shapeType == ShapeType.ARCZ) {
double[] zExtreame = JTSUtilities.zMinMax(coords);
if (Double.isNaN(zExtreame[0])) {
buffer.putDouble(0.0);
buffer.putDouble(0.0);
} else {
buffer.putDouble(zExtreame[0]);
buffer.putDouble(zExtreame[1]);
}
for (int t = 0; t < npoints; t++) {
double z = coords[t].z;
if (Double.isNaN(z)) {
buffer.putDouble(0.0);
} else {
buffer.putDouble(z);
}
}
}
if (shapeType == ShapeType.ARCZ) {
buffer.putDouble(-10E40);
buffer.putDouble(-10E40);
for (int t = 0; t < npoints; t++) {
buffer.putDouble(-10E40);
}
}
}