/** {@inheritDoc } */
@Override
public boolean evaluate(final Object object) {
Geometry leftGeom = toGeometry(object, left);
Geometry rightGeom = toGeometry(object, right);
if (leftGeom == null || rightGeom == null) {
return false;
}
final Geometry[] values;
try {
values = toSameCRS(leftGeom, rightGeom);
} catch (FactoryException | TransformException ex) {
Logging.getLogger("org.geotoolkit.filter.binaryspatial").log(Level.WARNING, null, ex);
return false;
}
leftGeom = values[0];
rightGeom = values[1];
final Envelope envLeft = leftGeom.getEnvelopeInternal();
final Envelope envRight = rightGeom.getEnvelopeInternal();
if (envLeft.intersects(envRight)) {
return leftGeom.overlaps(rightGeom);
}
return false;
}
@Override
public BoundingBox getBounds() {
// Calculate bounds?
//
if (bounds == null) {
//
// Initialize bounds
//
bounds = new ReferencedEnvelope(getFeatureType().getCoordinateReferenceSystem());
//
// Loop over all geometries
//
for (EFeatureGeometry<Geometry> it : eInternal.getGeometryList(Geometry.class)) {
if (!it.isEmpty()) {
Geometry g = it.getValue();
if (bounds.isNull()) {
bounds.init(g.getEnvelopeInternal());
} else {
bounds.expandToInclude(g.getEnvelopeInternal());
}
}
}
}
return bounds;
}
/** @see org.geotools.data.FeatureStore#setFeatures(org.geotools.data.FeatureReader) */
public void setFeatures(FeatureReader<SimpleFeatureType, SimpleFeature> reader)
throws IOException {
WFSTransactionState ts = null;
if (trans == Transaction.AUTO_COMMIT) {
ts = new WFSTransactionState(ds);
} else {
ts = (WFSTransactionState) trans.getState(ds);
}
ts.addAction(
getSchema().getTypeName(), new DeleteAction(getSchema().getTypeName(), Filter.INCLUDE));
ReferencedEnvelope bounds = null;
while (reader.hasNext()) {
try {
SimpleFeature f = reader.next();
List<AttributeDescriptor> atrs = f.getFeatureType().getAttributeDescriptors();
for (int i = 0; i < atrs.size(); i++) {
if (atrs.get(i) instanceof GeometryDescriptor) {
Geometry g = (Geometry) f.getAttribute(i);
CoordinateReferenceSystem cs =
((GeometryDescriptor) atrs.get(i)).getCoordinateReferenceSystem();
if (cs != null && !cs.getIdentifiers().isEmpty())
g.setUserData(cs.getIdentifiers().iterator().next().toString());
if (g == null) continue;
if (bounds == null) {
bounds = new ReferencedEnvelope(g.getEnvelopeInternal(), cs);
} else {
bounds.expandToInclude(g.getEnvelopeInternal());
}
}
}
ts.addAction(getSchema().getTypeName(), new InsertAction(f));
} catch (NoSuchElementException e) {
WFS_1_0_0_DataStore.LOGGER.warning(e.toString());
} catch (IllegalAttributeException e) {
WFS_1_0_0_DataStore.LOGGER.warning(e.toString());
}
}
// Fire a notification.
// JE
if (bounds == null) {
// if bounds are null then send an envelope to say that features were added but
// at an unknown location.
bounds = new ReferencedEnvelope(getSchema().getCoordinateReferenceSystem());
((WFS_1_0_0_DataStore) getDataStore())
.listenerManager.fireFeaturesRemoved(
getSchema().getTypeName(), getTransaction(), bounds, false);
} else {
((WFS_1_0_0_DataStore) getDataStore())
.listenerManager.fireFeaturesRemoved(
getSchema().getTypeName(), getTransaction(), bounds, false);
}
if (trans == Transaction.AUTO_COMMIT) {
ts.commit();
}
}
/**
* @see org.geotools.data.FeatureStore#modifyFeatures(org.geotools.feature.AttributeType[],
* java.lang.Object[], org.geotools.filter.Filter)
*/
public void modifyFeatures(Name[] names, Object[] value, Filter filter2) throws IOException {
Filter filter = ds.processFilter(filter2);
WFSTransactionState ts = null;
if (trans == Transaction.AUTO_COMMIT) {
ts = new WFSTransactionState(ds);
} else {
ts = (WFSTransactionState) trans.getState(ds);
}
Map<String, Object> props = new HashMap<String, Object>();
ReferencedEnvelope bounds = null;
for (int i = 0; i < names.length; i++) {
if (names[i] instanceof GeometryDescriptor) {
Geometry g = (Geometry) value[i];
CoordinateReferenceSystem cs =
((GeometryDescriptor) names[i]).getCoordinateReferenceSystem();
if (cs != null && !cs.getIdentifiers().isEmpty())
g.setUserData(cs.getIdentifiers().iterator().next().toString());
g.setUserData(cs.getIdentifiers().iterator().next().toString());
if (cs != null && !cs.getIdentifiers().isEmpty())
g.setUserData(cs.getIdentifiers().iterator().next().toString());
// set/expand the bounds that are being changed.
if (g == null) continue;
if (bounds == null) {
bounds = new ReferencedEnvelope(g.getEnvelopeInternal(), cs);
} else {
bounds.expandToInclude(g.getEnvelopeInternal());
}
}
props.put(names[i].getLocalPart(), value[i]);
}
ts.addAction(
getSchema().getTypeName(), new UpdateAction(getSchema().getTypeName(), filter, props));
// Fire a notification.
// JE
if (bounds == null) {
// if bounds are null then send an envelope to say that features were modified but
// at an unknown location.
bounds = new ReferencedEnvelope(getSchema().getCoordinateReferenceSystem());
((WFS_1_0_0_DataStore) getDataStore())
.listenerManager.fireFeaturesRemoved(
getSchema().getTypeName(), getTransaction(), bounds, false);
} else {
((WFS_1_0_0_DataStore) getDataStore())
.listenerManager.fireFeaturesRemoved(
getSchema().getTypeName(), getTransaction(), bounds, false);
}
if (trans == Transaction.AUTO_COMMIT) {
ts.commit();
}
}
/**
* Ensure Line crosses the other Line at a node.
*
* <p>
*
* @param layers a HashMap of key="TypeName" value="FeatureSource"
* @param envelope The bounding box of modified features
* @param results Storage for the error and warning messages
* @return True if no features intersect. If they do then the validation failed.
* @throws Exception DOCUMENT ME!
* @see org.geotools.validation.IntegrityValidation#validate(java.util.Map,
* com.vividsolutions.jts.geom.Envelope, org.geotools.validation.ValidationResults)
*/
public boolean validate(Map layers, Envelope envelope, ValidationResults results)
throws Exception {
boolean r = true;
FeatureSource<SimpleFeatureType, SimpleFeature> fsLine =
(FeatureSource<SimpleFeatureType, SimpleFeature>) layers.get(getLineTypeRef());
FeatureCollection<SimpleFeatureType, SimpleFeature> fcLine = fsLine.getFeatures();
FeatureIterator<SimpleFeature> fLine = fcLine.features();
FeatureSource<SimpleFeatureType, SimpleFeature> fsRLine =
(FeatureSource<SimpleFeatureType, SimpleFeature>) layers.get(getRestrictedLineTypeRef());
FeatureCollection<SimpleFeatureType, SimpleFeature> fcRLine = fsRLine.getFeatures();
while (fLine.hasNext()) {
SimpleFeature line = fLine.next();
FeatureIterator<SimpleFeature> fRLine = fcRLine.features();
Geometry lineGeom = (Geometry) line.getDefaultGeometry();
if (envelope.contains(lineGeom.getEnvelopeInternal())) {
// check for valid comparison
if (LineString.class.isAssignableFrom(lineGeom.getClass())) {
while (fRLine.hasNext()) {
SimpleFeature rLine = fRLine.next();
Geometry rLineGeom = (Geometry) rLine.getDefaultGeometry();
if (envelope.contains(rLineGeom.getEnvelopeInternal())) {
if (LineString.class.isAssignableFrom(rLineGeom.getClass())) {
if (lineGeom.intersects(rLineGeom)) {
if (!hasPair(
((LineString) lineGeom).getCoordinateSequence(),
((LineString) rLineGeom).getCoordinateSequence())) {
results.error(
rLine,
"Line does not intersect line at node covered by the specified Line.");
r = false;
}
} else {
results.warning(rLine, "Does not intersect the LineString");
}
// do next.
} else {
fcRLine.remove(rLine);
results.warning(
rLine, "Invalid type: this feature is not a derivative of a LineString");
}
} else {
fcRLine.remove(rLine);
}
}
} else {
results.warning(line, "Invalid type: this feature is not a derivative of a LineString");
}
}
}
return r;
}
public double measure(Geometry g1, Geometry g2) {
double distance = DiscreteHausdorffDistance.distance(g1, g2, DENSIFY_FRACTION);
Envelope env = new Envelope(g1.getEnvelopeInternal());
env.expandToInclude(g2.getEnvelopeInternal());
double envSize = diagonalSize(env);
// normalize so that more similarity produces a measure closer to 1
double measure = 1 - distance / envSize;
// System.out.println("Hausdorff distance = " + distance + ", measure = " + measure);
return measure;
}
public static void getRelationsInfo(List<Geometry> aGeometryList) {
int numVar = aGeometryList.size();
int[] numRel = new int[8];
int sum = 0;
for (int i1 = 0; i1 < numVar; i1++) {
Geometry a1 = aGeometryList.get(i1);
Envelope a1m = a1.getEnvelopeInternal();
double[] m1 = new double[4];
m1[0] = a1m.getMinX();
m1[1] = a1m.getMaxX();
m1[2] = a1m.getMinY();
m1[3] = a1m.getMaxY();
for (int j1 = i1 + 1; j1 < numVar; j1++) {
Geometry a2 = aGeometryList.get(j1);
Envelope a2m = a2.getEnvelopeInternal();
double[] m2 = new double[4];
m2[0] = a2m.getMinX();
m2[1] = a2m.getMaxX();
m2[2] = a2m.getMinY();
m2[3] = a2m.getMaxY();
boolean[] relationAB = new boolean[8];
// assume relation table is indexed by i*n+j for each pair (i,j), i<j
relationAB = GeometryRelated.computeRCC8RelationMBR(a1, a2, m1, m2);
if (GeometryRelated.rectangleIntersect(m1, m2)) {
sum += 2;
}
for (int k = 0; k < 8; k++) {
// we already know relation is basic
if (relationAB[k]) {
numRel[k]++;
break;
}
}
}
}
System.out.println("DC number:" + numRel[0]);
System.out.println("EC number:" + numRel[1]);
System.out.println("PO number:" + numRel[2]);
System.out.println("NTPP number:" + numRel[3]);
System.out.println("TPP number:" + numRel[4]);
System.out.println("NTPPi number:" + numRel[5]);
System.out.println("TPPi number:" + numRel[6]);
System.out.println("EQ number:" + numRel[7]);
System.out.println("Average Intersection Degree: " + ((double) sum / ((double) numVar)));
}
/**
* Returns all the FeatureId and ID attributes based on the query against the spatial index
*
* @return all the FeatureId and ID attributes based on the query against the spatial index
*/
protected synchronized Map<String, FeatureId> unrefinedSpatialMatches() {
if (_unrefinedMatches == null) {
Geometry geom = null;
// _index.query returns geometries that intersect with provided envelope. To use later a
// spatial filter that
// provides geometries that don't intersect with the query envelope (_geom) should be used a
// full extent
// envelope in this method, instead of the query envelope (_geom)
if (getFilter().getClass().getName().equals("org.geotools.filter.spatial.DisjointImpl")) {
try {
geom = WORLD_BOUNDS;
} catch (Exception ex) {
ex.printStackTrace();
return _unrefinedMatches;
}
} else {
geom = _geom;
}
SpatialIndex spatialIndex = sourceAccessor.two();
@SuppressWarnings("unchecked")
List<Pair<FeatureId, String>> fids = spatialIndex.query(geom.getEnvelopeInternal());
_unrefinedMatches = new HashMap<>();
for (Pair<FeatureId, String> match : fids) {
_unrefinedMatches.put(match.two(), match.one());
}
}
return _unrefinedMatches;
}
/**
* Fits screen to specified geometry bounds.
*
* @param aArea A geometry in geo coordinates space.
* @throws Exception
*/
public void fit(Geometry aArea) throws Exception {
Geometry bounds = aArea.getBoundary();
Envelope envBounds = bounds.getEnvelopeInternal();
Point2D.Double leftUpCorner = new Point2D.Double(envBounds.getMinX(), envBounds.getMinY());
Point2D.Double rightBottomCorner = new Point2D.Double(envBounds.getMaxX(), envBounds.getMaxY());
Point2D.Double cartlu = geo2Cartesian(leftUpCorner);
Point2D.Double cartrb = geo2Cartesian(rightBottomCorner);
double destWidth = Math.abs(cartrb.getX() - cartlu.getX());
double destHeight = Math.abs(cartrb.getY() - cartlu.getY());
Coordinate centre =
new Coordinate((cartrb.getX() + cartlu.getX()) / 2, (cartrb.getY() + cartlu.getY()) / 2);
Dimension size = getSize();
Point2D.Double screenLT = awtScreen2Cartesian(new Point(0, 0));
Point2D.Double screenBR = awtScreen2Cartesian(new Point(size.width, size.height));
double srcWidth = screenBR.x - screenLT.x;
double srcHeight = screenBR.y - screenLT.y;
double sx = srcWidth / destWidth;
double sy = srcHeight / destHeight;
double coef = Math.min(sx, sy);
coef = snapScale(coef);
scaleView(coef, coef, false);
Point2D.Double projectedScreenCenter = screen2Cartesian(new Point(0, 0));
translateView(projectedScreenCenter.x - centre.x, projectedScreenCenter.y - centre.y, true);
repaint();
}
@Override
public void marshal(Object value, HierarchicalStreamWriter writer, MarshallingContext context) {
if (value != null) {
Wfs20FeatureCollection wfc = (Wfs20FeatureCollection) value;
String schemaLoc = generateSchemaLocationFromMetacards(wfc.getMembers(), prefixToUriMapping);
for (Entry<String, String> entry : prefixToUriMapping.entrySet()) {
writer.addAttribute(XMLConstants.XMLNS_ATTRIBUTE + ":" + entry.getKey(), entry.getValue());
}
writer.addAttribute(Wfs20Constants.ATTRIBUTE_SCHEMA_LOCATION, schemaLoc);
Geometry allGeometry = getBounds(wfc.getMembers());
if (!allGeometry.isEmpty()) {
XmlNode.writeEnvelope(
Wfs20Constants.GML_PREFIX + ":" + "boundedBy",
context,
writer,
allGeometry.getEnvelopeInternal());
}
for (Metacard mc : wfc.getMembers()) {
writer.startNode(Wfs20Constants.GML_PREFIX + ":" + FEATURE_MEMBER);
context.convertAnother(mc);
writer.endNode();
}
} else {
LOGGER.warn("Incoming value was null");
}
}
@Override
public void reset() throws SQLException {
cellI = 0;
cellJ = 0;
firstRow = false;
// We compute the extend according the first input value
if (isTable) {
Statement statement = connection.createStatement();
ResultSet rs =
statement.executeQuery(
"select ST_Extent("
+ getFirstGeometryField(tableName, connection)
+ ") from "
+ tableName);
try {
rs.next();
Geometry geomExtend = (Geometry) rs.getObject(1);
if (geomExtend == null) {
throw new SQLException("The envelope cannot be null.");
} else {
envelope = geomExtend.getEnvelopeInternal();
initParameters();
}
} finally {
rs.close();
}
} else {
if (envelope == null) {
throw new SQLException("The input geometry used to compute the grid cannot be null.");
} else {
initParameters();
}
}
}
public synchronized void initIndexes() {
if (vertexIndex != null) {
return;
}
graphService.setLoadLevel(LoadLevel.DEBUG);
Graph graph = graphService.getGraph();
vertexIndex = new STRtree();
edgeIndex = new STRtree();
for (Vertex v : graph.getVertices()) {
Envelope vertexEnvelope = new Envelope(v.getCoordinate());
vertexIndex.insert(vertexEnvelope, v);
for (Edge e : v.getOutgoing()) {
Envelope envelope;
Geometry geometry = e.getGeometry();
if (geometry == null) {
envelope = vertexEnvelope;
} else {
envelope = geometry.getEnvelopeInternal();
}
edgeIndex.insert(envelope, e);
}
}
vertexIndex.build();
edgeIndex.build();
}
public MCIndexedPointInAreaLocator(Geometry g) {
areaGeom = g;
if (!(g instanceof Polygonal)) throw new IllegalArgumentException("Argument must be Polygonal");
buildIndex(g);
Envelope env = g.getEnvelopeInternal();
maxXExtent = env.getMaxX() + 1.0;
}
/**
* Returns the minimal y-value of the given geometry.
*
* @param geom Geometry
* @return The minimal y-value of the given geometry, or null if the geometry is null.
*/
public static Double getMinY(Geometry geom) {
if (geom != null) {
return geom.getEnvelopeInternal().getMinY();
} else {
return null;
}
}
@Override
protected Envelope getEnvelope(final TestGeometry entry) {
// incorporate the bounding box of the entry's envelope
final Geometry geometry = entry.geom;
if ((geometry != null) && !geometry.isEmpty()) {
return geometry.getEnvelopeInternal();
}
return null;
}
public static ArrayList<String> getListOfSensors(String envelope) throws ParseException {
Geometry geom = new WKTReader().read(envelope);
List listEnvelope = geoIndex.query(geom.getEnvelopeInternal());
ArrayList<String> sensors = new ArrayList<String>();
for (int i = 0; i < listEnvelope.size(); i++) {
sensors.add(searchForSensors_String((Point) listEnvelope.get(i)));
}
return sensors;
}
@Test
public void toEnvelope() {
Coordinate[] coords = getPolyCoords();
GeometryFactory gf = new GeometryFactory();
Geometry geom = gf.createPolygon(gf.createLinearRing(coords), null);
ReferencedEnvelope refEnv = JTS.toEnvelope(geom);
assertTrue(geom.getEnvelopeInternal().equals(refEnv));
}
public static void getAIDMem(List<Geometry> aGeometryList) {
int numVar = aGeometryList.size();
// int[] numRel = new int[8];
int sum = 0;
for (int i1 = 0; i1 < numVar; i1++) {
Geometry a1 = aGeometryList.get(i1);
Envelope a1m = a1.getEnvelopeInternal();
// double[] m1 = new double[4];
// m1[0] = a1m.getMinX();
// m1[1] = a1m.getMaxX();
// m1[2] = a1m.getMinY();
// m1[3] = a1m.getMaxY();
for (int j1 = i1 + 1; j1 < numVar; j1++) {
Geometry a2 = aGeometryList.get(j1);
Envelope a2m = a2.getEnvelopeInternal();
// double[] m2 = new double[4];
// m2[0] = a2m.getMinX();
// m2[1] = a2m.getMaxX();
// m2[2] = a2m.getMinY();
// m2[3] = a2m.getMaxY();
// int[] relationAB = new int[8];
// assume relation table is indexed by i*n+j for each pair (i,j), i<j
// relationAB = GeometryRelated.computeRCC8RelationMBR(a1, a2, m1, m2);
// if(GeometryRelated.rectangleIntersect(m1, m2)){
if (a1m.intersects(a2m)) {
sum += 2;
}
// for(int k=0;k<8;k++){
// //we already know relation is basic
// if(relationAB[k]==1){
// numRel[k]++;
// break;
// }
// }
}
}
System.out.println("Average Intersection Degree: " + ((double) sum / ((double) numVar)));
}
@Test
public void toGeometry_BoundingBox() {
BoundingBox bbox = new ReferencedEnvelope(-10, 10, -5, 5, null);
Geometry geom = JTS.toGeometry(bbox);
assertTrue(geom instanceof com.vividsolutions.jts.geom.Polygon);
Envelope geomEnv = geom.getEnvelopeInternal();
assertEquals(-10.0, geomEnv.getMinX(), TOL);
assertEquals(10.0, geomEnv.getMaxX(), TOL);
assertEquals(-5.0, geomEnv.getMinY(), TOL);
assertEquals(5.0, geomEnv.getMaxY(), TOL);
}
@Test
public void toGeometry_Envelope() {
Envelope refEnv = new Envelope(-10, 10, -5, 5);
Geometry geom = JTS.toGeometry(refEnv);
assertTrue(geom instanceof com.vividsolutions.jts.geom.Polygon);
Envelope geomEnv = geom.getEnvelopeInternal();
assertEquals(-10.0, geomEnv.getMinX(), TOL);
assertEquals(10.0, geomEnv.getMaxX(), TOL);
assertEquals(-5.0, geomEnv.getMinY(), TOL);
assertEquals(5.0, geomEnv.getMaxY(), TOL);
}
@Test
public void toGeometry_ReferencedEnvelope() {
ReferencedEnvelope refEnv = new ReferencedEnvelope(-10, 10, -5, 5, DefaultGeographicCRS.WGS84);
Geometry geom = JTS.toGeometry(refEnv);
assertTrue(geom instanceof com.vividsolutions.jts.geom.Polygon);
Envelope geomEnv = geom.getEnvelopeInternal();
assertEquals(-10.0, geomEnv.getMinX(), TOL);
assertEquals(10.0, geomEnv.getMaxX(), TOL);
assertEquals(-5.0, geomEnv.getMinY(), TOL);
assertEquals(5.0, geomEnv.getMaxY(), TOL);
}
/**
* 根据经度、纬度获取区域编码
*
* @param lon 经度
* @param lat 纬度
* @return
* @throws Exception long
*/
public static long getAreaAnalyzer(double lon, double lat) throws Exception {
long areacode = -1;
Geometry geo = new GeometryFactory().createPoint(new Coordinate(lon, lat));
List<?> areas = areaTree.query(geo.getEnvelopeInternal());
for (Object obj : areas) {
AreaNode anode = (AreaNode) obj;
if (anode.getPolygon().contains(geo)) {
areacode = anode.getAreaCode();
break;
}
}
return areacode;
}
/**
* @param geom
* @param seq
*/
private boolean decimateOnEnvelope(Geometry geom, LiteCoordinateSequence seq) {
Envelope env = geom.getEnvelopeInternal();
if (env.getWidth() <= spanx && env.getHeight() <= spany) {
double[] coords = seq.getArray();
int dim = seq.getDimension();
double[] newcoords = new double[dim * 2];
for (int i = 0; i < dim; i++) {
newcoords[i] = coords[i];
newcoords[dim + i] = coords[coords.length - dim + i];
}
seq.setArray(coords);
return true;
}
return false;
}
/*
* (non-Javadoc)
*
* @see org.geotools.gce.imagemosaic.jdbc.JDBCAccessBase#getEnvelopeFromResultSet(java.sql.ResultSet)
*/
@Override
protected Envelope getEnvelopeFromResultSet(ResultSet r) throws SQLException {
byte[] bytes = r.getBytes(2);
WKBReader reader = new WKBReader();
Geometry bbox = null;
try {
bbox = reader.read(bytes);
} catch (ParseException e) {
LOGGER.log(Level.SEVERE, e.getMessage(), e);
throw new SQLException(e.getMessage());
}
return bbox.getEnvelopeInternal();
}
/**
* areaTree全国区域拓扑树初始化
*
* @param fileName
* @throws Exception void
*/
public static void buildTree(String fileName) throws Exception {
FileInputStream fis = new FileInputStream(new File(fileName));
BufferedReader br = new BufferedReader(new InputStreamReader(fis, "utf-8"));
String line = null;
AreaNode node = null;
while ((line = br.readLine()) != null) { // 读取区域文件
String[] lines = line.split(";");
Geometry polygon = new WKTReader().read(lines[lines.length - 1]);
node = new AreaNode(); // 创建节点
node.setAreaCode(Long.parseLong(lines[0]));
node.setAreaName(lines[1]);
node.setPolygon(polygon);
areaTree.insert(polygon.getEnvelopeInternal(), node); // 向树上添加节点
}
fis.close();
br.close();
areaTree.build(); // 构建树
}
/**
* Gets the AWT {@link Shape} we'll use to represent {@code geom} on the map.
*
* @param geom The geometry we want to draw.
* @param generalize If true we'll perform generalization
* @return An AWT Shape instance.
*/
public Shape getShape(Geometry geom, boolean generalize) {
if (generalize) {
Rectangle2DDouble rectangle2dDouble = toPixel(geom.getEnvelopeInternal());
if ((rectangle2dDouble.getHeight() <= MAXPIXEL_DISPLAY)
&& (rectangle2dDouble.getWidth() <= MAXPIXEL_DISPLAY)) {
if (geom.getDimension() == 1) {
Coordinate[] coords = geom.getCoordinates();
return getShapeWriter()
.toShape(
geom.getFactory()
.createLineString(new Coordinate[] {coords[0], coords[coords.length - 1]}));
} else {
return rectangle2dDouble;
}
}
}
return getShapeWriter().toShape(geom);
}
Expression clipToWorld(BinarySpatialOperator filter, Expression e) {
if (e instanceof Literal) {
Geometry eval = e.evaluate(filter, Geometry.class);
// Oracle cannot deal with filters using geometries that span beyond the whole world
// in case the
if (dialect != null
&& isCurrentGeometryGeodetic()
&& !WORLD.contains(eval.getEnvelopeInternal())) {
Geometry result = eval.intersection(JTS.toGeometry(WORLD));
if (result != null && !result.isEmpty()) {
if (result instanceof GeometryCollection) {
result = distillSameTypeGeometries((GeometryCollection) result, eval);
}
e = new FilterFactoryImpl().createLiteralExpression(result);
}
}
}
return e;
}
/**
* It retrieves the features falling into the query condition. If the filter is not changed from
* the previous filter and the layer is not marked to be forcibly refreshed, it does not ask for
* features from the server, but it returns the former ones
*
* @param query The query (geotools) used to filter features
* @return
* @throws IOException
*/
@Override
public PojoFeatureCollection getFeatures(Query query) throws IOException {
Filter filter = query.getFilter();
if (filter == null) {
throw new UnsupportedOperationException(GisMessage.GENERAL_EXCEPTION_FILTER_NOTFOUND);
}
if (!(filter instanceof org.opengis.filter.spatial.BBOX)) {
throw new UnsupportedOperationException(GisMessage.GENERAL_EXCEPTION_TYPE_NOTSUPPORTED);
}
org.opengis.filter.spatial.BBOX bboxFilter = (org.opengis.filter.spatial.BBOX) filter;
org.geotools.filter.LiteralExpressionImpl literalExpression =
(org.geotools.filter.LiteralExpressionImpl) bboxFilter.getExpression2();
Geometry filteringGeometry = (Geometry) literalExpression.getValue();
Envelope boundingBox = (Envelope) filteringGeometry.getEnvelopeInternal();
double west = boundingBox.getMinX();
double east = boundingBox.getMaxX();
double south = boundingBox.getMinY();
double north = boundingBox.getMaxY();
this.ModifyFeatureCollection(west, south, east, north);
return this.collection;
}
public void runAlgorithm() throws IOException {
/*
* get tracks
*/
Envelope env = bbox.getEnvelopeInternal();
List<String> trackIDs = getTrackIDs(env.getMinX(), env.getMinY(), env.getMaxX(), env.getMaxY());
/*
* foreach track
*
*/
for (String trackID : trackIDs) {
runAlgorithm(trackID);
/*
* continue with next track
*/
}
}
/**
* This method computes reprojected bounds the hard way, but computing them feature by feature.
* This method could be faster if computed the reprojected bounds by reprojecting the original
* feature bounds a Shape object, thus getting the true shape of the reprojected envelope, and
* then computing the minimum and maximum coordinates of that new shape. The result would not a
* true representation of the new bounds.
*
* @see org.geotools.data.FeatureResults#getBounds()
*/
public ReferencedEnvelope getBounds() {
FeatureIterator<SimpleFeature> r = features();
try {
Envelope newBBox = new Envelope();
Envelope internal;
SimpleFeature feature;
while (r.hasNext()) {
feature = r.next();
final Geometry geom = ((Geometry) feature.getDefaultGeometry());
if (geom != null) {
internal = geom.getEnvelopeInternal();
newBBox.expandToInclude(internal);
}
}
return ReferencedEnvelope.reference(newBBox);
} catch (Exception e) {
throw new RuntimeException("Exception occurred while computing reprojected bounds", e);
} finally {
r.close();
}
}
