Java PrecisionModel.FLOATING_SINGLE屬性代碼示例

/**
 * Creates a new reference
 * @param envelope  the bounding envelope, which allows points
 *                  to be associated with their containing {@link com.foursquare.geo.shapes.indexing.CellLocation}s
 * @param levelSizes a list representing the maximum depth of the index (length of array)
 *                   and the 2D branching factor at each level (the value at each index)
 *                   a quadtree-like index, with a maximum depth of 5 could be realized
 *                   as <code>new int[]{2, 2, 2, 2, 2}</code>
 */
public CellLocationReference(ReferencedEnvelope envelope, int[] levelSizes) {
  this.envelope = envelope;
  this.levelSizes = levelSizes.clone();
  this.hashCodeValue = envelope.hashCode() + Arrays.hashCode(this.levelSizes);
  geometryFactory = new GeometryFactory(
    new PrecisionModel(PrecisionModel.FLOATING_SINGLE)
  );
  logger.debug("GeometryFactory using PrecisionModel {}", geometryFactory.getPrecisionModel());
}
 

@operator (
		value = { "inter", "intersection" },
		category = { IOperatorCategory.SPATIAL })
@doc (
		value = "A geometry resulting from the intersection between the two geometries",
		special_cases = { "returns nil if one of the operands is nil" },
		examples = { @example (
				value = "square(10) inter circle(5)",
				equals = "circle(5)") },
		see = { "union", "+", "-" })
public static IShape inter(final IScope scope, final IShape g1, final IShape g2) {
	if (g2 == null || g1 == null) { return null; }
	if (g2.isPoint() && g1.covers(g2.getLocation())) { return g2.copy(scope); }
	if (g1.isPoint() && g2.covers(g1.getLocation())) { return g1.copy(scope); }
	Geometry geom = null;
	final Geometry geom1 = g1.getInnerGeometry();
	final Geometry geom2 = g2.getInnerGeometry();
	try {

		geom = geom1.intersection(geom2);
	} catch (final Exception ex) {
		try {
			final PrecisionModel pm = new PrecisionModel(PrecisionModel.FLOATING_SINGLE);
			geom = GeometryPrecisionReducer.reducePointwise(geom1, pm)
					.intersection(GeometryPrecisionReducer.reducePointwise(geom2, pm));
		} catch (final Exception e) {
			// AD 12/04/13 : Addition of a third method in case of
			// exception
			try {
				geom = geom1.buffer(0.01, BufferParameters.DEFAULT_QUADRANT_SEGMENTS, BufferParameters.CAP_FLAT)

						.intersection(geom2.buffer(0.01, BufferParameters.DEFAULT_QUADRANT_SEGMENTS,
								BufferParameters.CAP_FLAT));
			} catch (final Exception e2) {
				return null;
			}
		}
	}
	if (geom == null || geom.isEmpty()) { return null; }
	// WARNING The attributes of the left-hand shape are kept, but not
	// those of the right-hand shape
	final GamaShape result = new GamaShape(g1, geom);
	result.losePredefinedProperty();
	return result;
}
 

@operator (
		value = { "+", "union" },
		category = { IOperatorCategory.SPATIAL },
		concept = { IConcept.GEOMETRY, IConcept.SPATIAL_COMPUTATION })
@doc (
		usages = @usage (
				value = "if the right-operand is a point, a geometry or an agent, returns the geometry resulting from the union between both geometries",
				examples = @example (
						value = "geom1 + geom2",
						equals = "a geometry corresponding to union between geom1 and geom2",
						isExecutable = false)))
public static IShape union(final IScope scope, final IShape g1, final IShape g2) {
	if (g1 == null) {
		if (g2 == null) { return null; }
		return g2.copy(scope);
	}
	if (g2 == null) { return g1.copy(scope); }
	final Geometry geom1 = g1.getInnerGeometry();
	final Geometry geom2 = g2.getInnerGeometry();
	Geometry geom;
	try {
		geom = geom1.union(geom2);
	} catch (final Exception e) {
		try {
			final PrecisionModel pm = new PrecisionModel(PrecisionModel.FLOATING_SINGLE);
			geom = GeometryPrecisionReducer.reducePointwise(geom1, pm)
					.intersection(GeometryPrecisionReducer.reducePointwise(geom2, pm));
		} catch (final Exception e1) {
			try {
				geom = Spatial.Transformations.translated_by(scope, g2.copy(scope), new GamaPoint(0.01, 0))
						.getInnerGeometry().union(geom1);

			} catch (final Exception e2) {
				// AD 12/04/13 : Addition of a third method in case of
				// exception
				try {
					geom = geom1.buffer(0.01, 0, BufferParameters.CAP_SQUARE)
							.union(geom2.buffer(0.01, 0, BufferParameters.CAP_SQUARE));
				} catch (final Exception e3) {
					geom = Spatial.Transformations.rotated_by(scope, g2.copy(scope), 0.1).getInnerGeometry()
							.union(geom1);
				}
			}
		}

	}
	if (geom == null || geom.isEmpty()) { return null; }
	final GamaShape result = new GamaShape(g1, geom);
	result.losePredefinedProperty();
	return result;
}
 

private ODLGeom calculateUnion(Iterable<ODLGeom> inputGeoms, String ESPGCode) {
	try {
		Spatial.initSpatial();
		GridTransforms transforms = new GridTransforms(ESPGCode);

		PrecisionModel pm = new PrecisionModel(PrecisionModel.FLOATING_SINGLE);
		GeometryPrecisionReducer reducer = new GeometryPrecisionReducer(pm);

		// process shapes into grid with reduced precision
		ArrayList<Geometry> gridGeoms = new ArrayList<>();
		for (ODLGeom geom : inputGeoms) {
			if (geom != null) {
				ODLGeomImpl gimpl = (ODLGeomImpl) geom;
				if (gimpl.getJTSGeometry() != null) {
					com.vividsolutions.jts.geom.Geometry g = gimpl.getJTSGeometry();

					// convert to grid
					g = JTS.transform(g, transforms.getWGS84ToGrid().getMathTransform());

					// reduce precision as it stops holes appearing with our UK postcode data
					g = reducer.reduce(g);

					gridGeoms.add(g);

				}

			}
		}

		if (gridGeoms.size() == 0) {
			return null;
		}

		// combine
		Geometry combinedGrid = combineIntoOneGeometry(gridGeoms);

		// transform back
		Geometry combinedWGS84 = JTS.transform(combinedGrid, transforms.getGridToWGS84().getMathTransform());

		return new ODLLoadedGeometry(combinedWGS84);
	} catch (Exception e) {
		throw new RuntimeException(e);
	}

}
 

@Provides
@Singleton
public PrecisionModel precisionModel() {
    return new PrecisionModel(PrecisionModel.FLOATING_SINGLE);
}