Java Code Examples for com.vividsolutions.jts.geom.Geometry#apply()

/**
 * Creates facet sequences
 * 
 * @param g
 * @return List<GeometryFacetSequence>
 */
private static List computeFacetSequences(Geometry g) {
  final List sections = new ArrayList();

  g.apply(new GeometryComponentFilter() {

    public void filter(Geometry geom) {
      CoordinateSequence seq = null;
      if (geom instanceof LineString) {
        seq = ((LineString) geom).getCoordinateSequence();
        addFacetSequences(seq, sections);
      }
      else if (geom instanceof Point) {
        seq = ((Point) geom).getCoordinateSequence();
        addFacetSequences(seq, sections);
      }
    }
  });
  return sections;
}
 

private Collection<Geometry> getLines(final Geometry geom) {
	final List<Geometry> linesList = new ArrayList<Geometry>();
	final LinearComponentExtracter lineFilter = new LinearComponentExtracter(
			linesList);

	geom.apply(lineFilter);

	return linesList;
}
 

public static void applyToInnerGeometries(final GeometryCollection g, final GeometryFilter f) {
	final int geoms = g.getNumGeometries();
	if (geoms == 0) { return; }
	for (int i = 0; i < geoms; i++) {
		final Geometry sub = g.getGeometryN(i);
		sub.apply(f);
	}
}
 

void checkTransformation(String geomStr) throws IOException, ParseException,
    NoninvertibleTransformationException {
  Geometry geom = rdr.read(geomStr);
  AffineTransformation trans = AffineTransformation
      .rotationInstance(Math.PI / 2);
  AffineTransformation inv = trans.getInverse();
  Geometry transGeom = geom.copy();
  transGeom.apply(trans);
  // System.out.println(transGeom);
  transGeom.apply(inv);
  // check if transformed geometry is equal to original
  boolean isEqual = geom.equalsExact(transGeom, 0.0005);
  assertTrue(isEqual);
}
 

/**
 * Adds a {@link Geometry} to be dissolved. 
 * Any number of geometries may be adde by calling this method multiple times.
 * Any type of Geometry may be added.  The constituent linework will be
 * extracted to be dissolved.
 * 
 * @param geometry geometry to be line-merged
 */  
public void add(Geometry geometry) {
  geometry.apply(new GeometryComponentFilter() {
    public void filter(Geometry component) {
      if (component instanceof LineString) {
        add((LineString)component);
      }
    }      
  });
}
 

/**
 * Adds a Geometry to be processed. May be called multiple times.
 * Any dimension of Geometry may be added; the constituent linework will be
 * extracted.
 * 
 * @param geometry geometry to be line-merged
 */  
public void add(Geometry geometry) {
  geometry.apply(new GeometryComponentFilter() {
    public void filter(Geometry component) {
      if (component instanceof LineString) {
        add((LineString)component);
      }
    }      
  });
}
 

public static void translate(final Geometry geometry, final double dx, final double dy, final double dz) {
	geometry.apply((final Coordinate p) -> {
		p.x += dx;
		p.y += dy;
		p.z += dz;
	});
	geometry.geometryChanged();
}
 

public void readShapes(final IScope scope) {
	final IList<IShape> list = getBuffer();
	int size = 0;
	final SimpleFeatureCollection fc = getFeatureCollection(scope);
	if (fc == null) { return; }
	final Envelope3D env = Envelope3D.of(fc.getBounds());
	size = fc.size();
	int index = 0;
	computeProjection(scope, env);
	try (SimpleFeatureIterator reader = fc.features()) {
		while (reader.hasNext()) {
			index++;
			if (index % 20 == 0) {
				scope.getGui().getStatus(scope).setSubStatusCompletion(index / (double) size);
			}
			final SimpleFeature feature = reader.next();
			Geometry g = (Geometry) feature.getDefaultGeometry();
			if (g != null && !g.isEmpty() /* Fix for Issue 725 && 677 */ ) {
				g = gis.transform(g);
				if (!with3D) {
					g.apply(ZERO_Z);
					g.geometryChanged();
				}
				list.add(new GamaGisGeometry(g, feature));
			} else if (g == null) {
				// See Issue 725
				GAMA.reportError(scope,
						GamaRuntimeException
								.warning("GamaGeoJsonFile.fillBuffer; geometry could not be added  as it is "
										+ "nil: " + feature.getIdentifier(), scope),
						false);
			}
		}
	}
	if (size > list.size()) {
		GAMA.reportError(scope, GamaRuntimeException.warning("Problem with file " + getFile(scope) + ": only "
				+ list.size() + " of the " + size + " geometries could be added", scope), false);
	}
}
 

@Override
public Geometry inverseTransform(Geometry geom) {
	if (inverseScaling != null) {
		geom.apply(inverseScaling);
		geom.geometryChanged();
	}
	return geom;
}
 

public void testUniqueCoordinateArrayFilter() throws Exception {
  Geometry g = reader.read(
        "MULTIPOINT(10 10, 20 20, 30 30, 20 20, 10 10)");
  UniqueCoordinateArrayFilter f = new UniqueCoordinateArrayFilter();
  g.apply(f);
  assertEquals(3, f.getCoordinates().length);
  assertEquals(new Coordinate(10, 10), f.getCoordinates()[0]);
  assertEquals(new Coordinate(20, 20), f.getCoordinates()[1]);
  assertEquals(new Coordinate(30, 30), f.getCoordinates()[2]);
}
 

@Override
public void inverseConvertUnit(Geometry geom) {
	if (meterToOtherUnit != null) {
		geom.apply(meterToOtherUnit);
		geom.geometryChanged();
	}
}
 

@Override
public void convertUnit(Geometry geom) {
	if (otherUnitToMeter != null) {
		geom.apply(otherUnitToMeter);
		geom.geometryChanged();
	}
	
}
 

@Override
public void inverseTranslate(final Geometry geom) {
	if (absoluteToGisTranslation != null) {
		geom.apply(absoluteToGisTranslation);
		geom.geometryChanged();
	}
}
 

@Override
public void translate(final Geometry geom) {
	if (gisToAbsoluteTranslation != null) {
		geom.apply(gisToAbsoluteTranslation);
		geom.geometryChanged();
	}
}
 

private Collection<Geometry> getLines(final Geometry geom1, final Geometry geom2) {
	final List<Geometry> linesList = new ArrayList<Geometry>();
	final LinearComponentExtracter lineFilter = new LinearComponentExtracter(
			linesList);

	geom1.apply(lineFilter);
	geom2.apply(lineFilter);

	return linesList;
}
 

protected void readShapes(final IScope scope) {
	scope.getGui().getStatus(scope).beginSubStatus("Reading file " + getName(scope));
	ShapefileDataStore store = null;
	final File file = getFile(scope);
	final IList list = getBuffer();
	int size = 0;
	try {
		store = getDataStore(file.toURI().toURL());
		final ContentFeatureSource source = store.getFeatureSource();
		final Envelope3D env = Envelope3D.of(source.getBounds());
		size = source.getCount(Query.ALL);
		int index = 0;
		computeProjection(scope, env);
		try (FeatureReader reader = store.getFeatureReader()) {
			while (reader.hasNext()) {
				index++;
				if (index % 20 == 0) {
					scope.getGui().getStatus(scope).setSubStatusCompletion(index / (double) size);
				}
				final Feature feature = reader.next();
				Geometry g = (Geometry) feature.getDefaultGeometryProperty().getValue();
				if (g != null && !g.isEmpty() /* Fix for Issue 725 && 677 */ ) {
					if (!with3D && !g.isValid()) {
						g = GeometryUtils.cleanGeometry(g);
					}
					g = gis.transform(g);
					if (!with3D) {
						g.apply(ZERO_Z);
						g.geometryChanged();
					}
					g = multiPolygonManagement(g);
					GamaGisGeometry gt = new GamaGisGeometry(g, feature);
					if (gt.getInnerGeometry() != null)
						list.add(gt);
					
				} else if (g == null) {
					// See Issue 725
					GAMA.reportError(scope,
							GamaRuntimeException
									.warning("GamaShapeFile.fillBuffer; geometry could not be added  as it is "
											+ "nil: " + feature.getIdentifier(), scope),
							false);
				}
			}
		}
	} catch (final IOException e) {
		throw GamaRuntimeException.create(e, scope);
	} finally {
		if (store != null) {
			store.dispose();
		}
		scope.getGui().getStatus(scope).endSubStatus("Reading file " + getName(scope));
	}
	if (size > list.size()) {
		GAMA.reportError(scope, GamaRuntimeException.warning("Problem with file " + getFile(scope) + ": only "
				+ list.size() + " of the " + size + " geometries could be added", scope), false);
	}
}
 

public static void rotate(final Geometry geometry, final GamaPoint center, final AxisAngle rotation) {
	if (rotation == null) { return; }
	final Rotation3D r = new Rotation3D.CenteredOn(rotation, center);
	geometry.apply(r);
	geometry.geometryChanged();
}
 

void drawSimpleGeometry(final OpenGL gl, final Geometry geom) throws ExecutionException {
	geom.apply((GeometryFilter) (g) -> drawer.accept(g));
}
 

private void setZ(Geometry g)
{
  g.apply(new AverageZFilter());
}
 

/**
 * Add a {@link Geometry} to the edges to be polygonized.
 * May be called multiple times.
 * Any dimension of Geometry may be added;
 * the constituent linework will be extracted and used
 *
 * @param g a {@link Geometry} with linework to be polygonized
 */
public void add(Geometry g)
{
  g.apply(lineStringAdder);
}