java.lang.Object
- com.esri.arcgisruntime.geometry.GeometryEngine

```
public final class GeometryEngine
extends Object
```
Performs geometric operations such as spatial relationship tests, reprojections, shape manipulations, topological query, analysis operations, and spatial operations on Geometry objects. Spatial relationship tests are based on the Dimensionally Extended 9 Intersection Model (DE-9IM) developed by Clementini et al.
Capabilities include:
- Create new geometries from others with buffer(Geometry, double), clip(Geometry, Envelope), and union(Geometry, Geometry).
- Test spatial relationships between geometries such as intersects(Geometry, Geometry), and contains(Geometry, Geometry).
- Find the nearestCoordinate(Geometry, Point) or nearestVertex(Geometry, Point) between geometries.
- Reproject a geometry to another SpatialReference using project(Geometry, SpatialReference).
- Calculate area and length using area(Polygon) and length(Polyline), or the geodetic equivalents (bufferGeodetic(Geometry, double, LinearUnit, double, GeodeticCurveType) and lengthGeodetic(Geometry, LinearUnit, GeodeticCurveType)) that account for the curvature of the earth.
GeometryEngine generally operates in two dimensions; operations do not account for z-values unless documented as such for a specific method (for example project(Geometry, SpatialReference) will transform z-values in some cases).
GeometryEngine provides both planar (Euclidean) and geodetic versions of many operations. Be aware that methods named with only the operation are the planar versions (buffer(Geometry, double), for example), while the geodetic equivalent has "Geodetic" appended to the name (for example bufferGeodetic(Geometry, double, LinearUnit, double, GeodeticCurveType)).
Geodetic methods are better suited to data that have a geographic spatial reference (see SpatialReference.isGeographic()), especially for large-area, small-scale use, while planar methods are suitable to data that have a projected coordinate system, especially for local, large-scale areas. Geodetic methods indicate this in the name, for examplebufferGeodetic(Geometry, double, LinearUnit, double, GeodeticCurveType).
Since:

100.0.0

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static double`	`area(Envelope envelope)`	Calculates the area for the Envelope passed in.
`static double`	`area(Polygon polygon)`	Calculates the area for the Polygon passed in.
`static double`	`areaGeodetic(Geometry geometry, AreaUnit areaUnit, GeodeticCurveType curveType)`	Calculates the area of the given geometry using a geodetic curve.
`static List<Polygon>`	`autoComplete(Iterable<Polygon> existingBoundaries, Iterable<Polyline> newBoundaries)`	Fills the closed gaps between polygons using polygon boundaries and polylines as the boundary for the new polygons.
`static Geometry`	`boundary(Geometry geometry)`	Calculates the boundary of the given geometry.
`static Polygon`	`buffer(Geometry geometry, double distance)`	Creates and returns a geometry object that represents a buffer polygon relative to the given geometry at the specified distance around the given geometry.
`static List<Polygon>`	`buffer(Iterable<Geometry> geometries, Iterable<Double> distances, boolean unionResult)`	Creates and returns a buffer or buffers relative to the specified collection of geometries.
`static Polygon`	`bufferGeodetic(Geometry geometry, double distance, LinearUnit distanceUnit, double maxDeviation, GeodeticCurveType curveType)`	Returns a geometry object that represents a buffer around the given geometry, calculated using a geodetic curve.
`static List<Polygon>`	`bufferGeodetic(Iterable<Geometry> geometries, Iterable<Double> distances, LinearUnit distanceUnit, double maxDeviation, GeodeticCurveType curveType, boolean unionResult)`	Creates a buffer or buffers relative to a collection of geometries, basing calculations on a geodesic curve.
`static Geometry`	`clip(Geometry geometry, Envelope envelope)`	Returns a geometry created by clipping the given Geometry with the given Envelope.
`static Envelope`	`combineExtents(Geometry geometry1, Geometry geometry2)`	Combines the extents of two given geometries.
`static Envelope`	`combineExtents(Iterable<Geometry> geometries)`	Combines the extents of a collection of geometries.
`static boolean`	`contains(Geometry container, Geometry within)`	Tests if geometry1 contains geometry2.
`static Geometry`	`convexHull(Geometry geometry)`	Calculates the convex hull of the given geometry.
`static List<Geometry>`	`convexHull(Iterable<Geometry> geometries, boolean unionResult)`	Calculates the convex hull or hulls of the geometries in the given collection.
`static Point`	`createPointAlong(Polyline polyline, double distance)`	Calculates the point at the given distance along the line.
`static boolean`	`crosses(Geometry geometry1, Geometry geometry2)`	Tests if geometry1 crosses geometry2.
`static List<Geometry>`	`cut(Geometry geometry, Polyline cutter)`	Cuts geometry with cutter.
`static Geometry`	`densify(Geometry geometry, double maxSegmentLength)`	Densifies the input geometry by inserting additional vertices along the geometry at an interval defined by `maxSegmentLength`.
`static Geometry`	`densifyGeodetic(Geometry geometry, double maxSegmentLength, LinearUnit lengthUnit, GeodeticCurveType curveType)`	Densifies the input geometry by creating additional vertices along the geometry, using a geodesic curve.
`static Geometry`	`difference(Geometry geometry1, Geometry geometry2)`	Constructs the set-theoretic difference between two geometries.
`static boolean`	`disjoint(Geometry geometry1, Geometry geometry2)`	Tests whether two geometries are disjoint.
`static double`	`distanceBetween(Geometry geometry1, Geometry geometry2)`	Measures the simple planar distance between two geometries.
`static GeodeticDistanceResult`	`distanceGeodetic(Point point1, Point point2, LinearUnit distanceUnit, AngularUnit azimuthUnit, GeodeticCurveType curveType)`	Calculates the distance between two Points, returning the result in the given linear unit of measurement.
`static Geometry`	`ellipseGeodesic(GeodesicEllipseParameters parameters)`	Calculates a geodesic ellipse (or geodesic circle, if semiAxis1Length = semiAxis2Length) centered on a specific point.
`static boolean`	`equals(Geometry geometry1, Geometry geometry2)`	Tests if two geometries are equal.
`static Polyline`	`extend(Polyline polyline, Polyline extender, ExtendOptions... extendOptions)`	Extends a polyline using a polyline as the extender.
`static double`	`fractionAlong(Polyline line, Point point, double tolerance)`	Finds the location on the line nearest the point, expressed as the fraction along the line's total geodesic length, if the point is within the specified distance from the the closest location on the line.
`static Geometry`	`generalize(Geometry geometry, double maxDeviation, boolean removeDegenerateParts)`	Generalizes the given geometry by removing vertices, based on the Douglas-Peucker algorithm.
`static Geometry`	`intersection(Geometry geometry1, Geometry geometry2)`	Calculates the intersection of two geometries.
`static List<Geometry>`	`intersections(Geometry geometry1, Geometry geometry2)`	Calculates the intersections of two geometries.
`static boolean`	`intersects(Geometry geometry1, Geometry geometry2)`	Tests if two geometries intersect.
`static boolean`	`isSimple(Geometry geometry)`	Indicates if this Geometry is topologically simple (in other words, is topologically correct).
`static Point`	`labelPoint(Polygon polygon)`	Calculates an interior point for the given polygon.
`static double`	`length(Polyline polyline)`	Calculates the length of the given polyline.
`static double`	`lengthGeodetic(Geometry geometry, LinearUnit lengthUnit, GeodeticCurveType curveType)`	Calculates the geodetic length of the geometry.
`static Point`	`moveGeodetic(Point point, double distance, LinearUnit distanceUnit, double azimuth, AngularUnit azimuthUnit, GeodeticCurveType curveType)`	Returns a new Point, moved by the given distance at the given azimuth (angle) from the given input Point.
`static List<Point>`	`moveGeodetic(List<Point> points, double distance, LinearUnit distanceUnit, double azimuth, AngularUnit azimuthUnit, GeodeticCurveType curveType)`	Returns a List of Points, moved by the given distance at the given azimuth (angle) from the given input List of Points.
`static ProximityResult`	`nearestCoordinate(Geometry geometry, Point point)`	Determines the nearest point in the input geometry to the input point using a simple planar measurement.
`static ProximityResult`	`nearestCoordinateGeodetic(Geometry geometry, Point point, double maxDeviation, LinearUnit deviationUnit)`	Determines the nearest point in the input geometry to the input point, by using a shape preserving geodesic approximation of the input geometry.
`static ProximityResult`	`nearestVertex(Geometry geometry, Point point)`	Returns a `ProximityResult` that describes the nearest vertex in the input geometry to the input point.
`static Geometry`	`normalizeCentralMeridian(Geometry geometry)`	Returns a copy of the input geometry that does not intersect the antimeridian.
`static Geometry`	`offset(Geometry geometry, double distance, GeometryOffsetType offsetType, double bevelRatio, double flattenError)`	Creates an offset version of the input geometry.
`static boolean`	`overlaps(Geometry geometry1, Geometry geometry2)`	Tests if two geometries overlap.
`static Geometry`	`project(Geometry geometry, SpatialReference spatialReference)`	Projects the given geometry from its current spatial reference system into the given spatial reference system, using the default geographic transformation.
`static Geometry`	`project(Geometry geometry, SpatialReference spatialReference, DatumTransformation datumTransformation)`	Projects the given geometry from its current spatial reference system into the given output spatial reference system, applying the datum transformation provided.
`static boolean`	`relate(Geometry geometry1, Geometry geometry2, String relation)`	Compares the spatial relationship of two geometries.
`static Geometry`	`removeM(Geometry geometry)`	Creates a copy of a geometry with its m values removed.
`static Geometry`	`removeZ(Geometry geometry)`	Creates a copy of a geometry with its z values removed.
`static Geometry`	`removeZAndM(Geometry geometry)`	Creates a copy of a geometry with its z- and m values removed.
`static Multipart`	`reshape(Multipart geometry, Polyline reshaper)`	Reshapes a polygon or polyline using a single path polyline as the `reshaper`.
`static Geometry`	`sectorGeodesic(GeodesicSectorParameters parameters)`	Creates a sector as a polygon, polyline or multipoint geometry.
`static Geometry`	`setM(Geometry geometry, double m)`	Creates a copy of a geometry with its m values set to the given value.
`static Geometry`	`setZ(Geometry geometry, double z)`	Creates a copy of a geometry with its z values set to the given value.
`static Geometry`	`setZAndM(Geometry geometry, double z, double m)`	Creates a copy of a geometry with its z- and m values set to the given values.
`static Geometry`	`simplify(Geometry geometry)`	Simplifies the given geometry to make it topologically consistent according to its geometry type.
`static Geometry`	`symmetricDifference(Geometry geometry1, Geometry geometry2)`	Calculates the symmetric difference (exclusive or) of the two geometries.
`static boolean`	`touches(Geometry geometry1, Geometry geometry2)`	Test if the two geometries touch on their borders.
`static Geometry`	`union(Geometry geometry1, Geometry geometry2)`	Calculates the union of the two geometries.
`static Geometry`	`union(Iterable<Geometry> geometries)`	Calculates the union of a collection of geometries.
`static boolean`	`within(Geometry within, Geometry container)`	Tests if `within` is within `container`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

area
```
public static double area(Envelope envelope)
```
Calculates the area for the Envelope passed in. This is a planar measurement to compute area for use on geometries using a projected coordinate system. Use areaGeodetic(Geometry, AreaUnit, GeodeticCurveType) for geodetic measurement.

Parameters:

envelope - envelope whose area is to be calculated

Returns:

area in units matching the envelope's spatial reference

Throws:

NullPointerException - if envelope is null

Since:

100.0.0

area
```
public static double area(Polygon polygon)
```
Calculates the area for the Polygon passed in. This is a planar measurement using 2D Cartesian mathematics to compute the area. Use areaGeodetic(Geometry, AreaUnit, GeodeticCurveType) for geodetic measurement.
The calculated area is based upon the SpatialReference of the input geometry. Planar measurements of distance and area can be extremely inaccurate if using an unsuitable spatial reference. Ensure that you understand the potential for error with the geometry's spatial reference.
Some spatial references are more appropriate than others for measuring area, and an 'area preserving' spatial reference would be most appropriate with this method. If the input geometry to this method is not in an 'area preserving' spatial reference, you can calculate more accurate results by doing one of the following:
- Use a different spatial reference. Use the project(Geometry, SpatialReference) method to project the geometry to a spatial reference that is better suited for area calculations.
- Use the geodetic equivalent: areaGeodetic(Geometry, AreaUnit, GeodeticCurveType).
See https://developers.arcgis.com/documentation/spatial-references/ for more information about spatial references.
The input geometry must be topologically correct to get its accurate area. Geometries returned by ArcGIS Server services are always topologically correct. If the geometry is not topologically correct, then the resultant area from this method could give negative results. Best practice is to simplify(Geometry) geometries before passing to this method.
Supports true curves.
Parameters:

polygon - polygon whose area is to be calculated

Returns:

area of the given polygon, in the same units as the polygon's spatial reference

Throws:

NullPointerException - if polygon is null

Since:

100.0.0

areaGeodetic
```
public static double areaGeodetic(Geometry geometry,
                                  AreaUnit areaUnit,
                                  GeodeticCurveType curveType)
```
Calculates the area of the given geometry using a geodetic curve.
The term geodesic means calculating the shortest distance between two points on a spheroid. Using geodesic algorithms to calculate distances provides a highly accurate way to obtain length and area of measurements of geographic features. The geodesic algorithm uses the concept of a great circle to obtain the shortest route between two points along the earth’s surface. The area measurement obtained via this method is typically superior to that of the area(Polygon) method, as area(Polygon) is based upon a projection (i.e. a flat 2D representation of a 3D surface) which often introduces distortion depending on the SpatialReference the geometry is in.
The input geometry must be topologically correct to get its accurate area. If the geometry is not topologically correct, then the resultant area from this method could give negative results. Best practice is to simplify(Geometry) geometries before passing to this method. Geometries returned by ArcGIS Server services are always correct. Therefore, if you construct geometries programmatically or using the sketch layer, or if you modify geometries returned by ArcGIS Server, you should always simplify them using simplify(Geometry) first.
Supports true curves, calculating the result by densifying curves.

Parameters:

geometry - geometry whose area is to be calculated

areaUnit - unit of measure for the return value. If null, defaults to unit of Id AreaUnitId.SQUARE_METERS

curveType - type of curve to calculate the geodetic area

Returns:

the geodetic area of the given geometry

Throws:

IllegalArgumentException - if geometry or curveType is null

Since:

100.0.0

autoComplete
```
public static List<Polygon> autoComplete(Iterable<Polygon> existingBoundaries,
                                         Iterable<Polyline> newBoundaries)
```
Fills the closed gaps between polygons using polygon boundaries and polylines as the boundary for the new polygons.
The new polygons are created in the closed empty areas bounded by the edges of the existing polygon boundaries and the new boundary polylines. The newly created polygons do not overlap any existing polygons or polylines, and the boundary of a new polygon must contain at least one edge from the polylines. Only polygons that intersect the input polylines will participate in the operation, so it makes sense to filter the input accordingly.
The geometries in existingBoundaries and newBoundaries must have consistent spatial references.

Parameters:

existingBoundaries - the polygons

newBoundaries - the polylines

Returns:

an unmodifiable list of the new polygons that were created; empty if either existingBoundaries or newBoundaries is empty

Throws:

IllegalArgumentException - if existingBoundaries or newBoundaries is null

ArcGISRuntimeException - if the geometries in existingBoundaries and newBoundaries have inconsistent spatial references

Since:

100.1.0

boundary
```
public static Geometry boundary(Geometry geometry)
```
Calculates the boundary of the given geometry.
- The boundary of a point is an empty geometry. Points have no boundary.
- The boundary of a polyline is a multipoint containing the end points of the polyline's parts.
- The boundary of a polygon is a polyline describing its outer and inner rings.
Supports true curves.
Parameters:

geometry - geometry whose boundary is to be calculated

Returns:

the boundary of the given geometry

Throws:

IllegalArgumentException - if geometry is null

Since:

100.0.0

buffer
```
public static Polygon buffer(Geometry geometry,
                             double distance)
```
Creates and returns a geometry object that represents a buffer polygon relative to the given geometry at the specified distance around the given geometry. This is a planar buffer operation. Use bufferGeodetic(Geometry, double, LinearUnit, double, GeodeticCurveType) to produce a geodetic buffer.
The returned polygon is based upon the SpatialReference of the input geometry. Planar measurements of distance and area can be extremely inaccurate if using an unsuitable spatial reference. Ensure that you understand the potential for error with the geometry's spatial reference. For this method, some spatial references are better than others for getting accurate results. To get the most accurate buffer polygons using this method, consider using an 'area preserving' spatial reference such as: Albers, Lambert, Mollweide, Hammer, Sinusoidal, etc.
If the input geometry to this method is not based on a good 'area preserving' spatial reference, then there are two options available to produce accurate buffers:
- Use the project(Geometry, SpatialReference) method to project the geometry to a coordinate system that is better suited for buffers.
- Use the bufferGeodetic(Geometry, double, LinearUnit, double, GeodeticCurveType). method which projects the geometry to a geographic coordinate system to obtain the most accurate buffers possible.
See https://developers.arcgis.com/documentation/spatial-references/ for more information about spatial references.
Supports true curves as input, producing a densified curve as output where applicable.
Parameters:

geometry - geometry to buffer

distance - buffer distance for the geometry in the same units as the geometry's spatial reference

Returns:

a polygon that represents a buffer at the desired distance around the given geometry

Throws:

NullPointerException - if geometry is null

Since:

100.0.0

buffer
```
public static List<Polygon> buffer(Iterable<Geometry> geometries,
                                   Iterable<Double> distances,
                                   boolean unionResult)
```
Creates and returns a buffer or buffers relative to the specified collection of geometries. The geometries must have the same spatial references. This is a planar buffer operation. Use bufferGeodetic(Iterable, Iterable, LinearUnit, double, GeodeticCurveType, boolean) to produce geodetic buffers.
The polygons returned from this method are based upon the SpatialReference of the input geometry. Planar measurements of distance and area can be extremely inaccurate if using an unsuitable spatial reference. Ensure that you understand the potential for error with the geometry's spatial reference. For this method, some spatial references are better than others for getting accurate results. To get the most accurate buffer polygons using this method, consider using an 'area preserving' SpatialReference such as: Albers, Lambert, Mollweide, Hammer, Sinusoidal, etc.
If the input geometry to this method is not based on a good 'area preserving' spatial reference, then there are two options available to produce accurate buffers:
- Use the project(Geometry, SpatialReference) method to project the geometry to a coordinate system that is better suited for buffers.
- Use the buffer(Iterable, Iterable, boolean) method, which projects the geometry to a geographic coordinate system to obtain the most accurate buffers possible.
See https://developers.arcgis.com/documentation/spatial-references/ for more information about spatial references.
Supports true curves as input, producing a densified curve as output where applicable.
Parameters:

geometries - the geometries to buffer

distances - the buffer distances for the geometries' in the same units as the geometry's spatial reference. If the number of distances is fewer than the number of geometries, the last distance value is used for the rest of the geometries.

unionResult - true to return a single geometry that buffers all the input geometries; false to return a separate buffer for each of the input geometries.

Returns:

an unmodifiable list containing either a single polygon or one polygon per input geometry, depending on the value of unionResult

Throws:

IllegalArgumentException - if geometries is null, or if distances is null or empty

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent

Since:

100.1.0

bufferGeodetic
```
public static Polygon bufferGeodetic(Geometry geometry,
                                     double distance,
                                     LinearUnit distanceUnit,
                                     double maxDeviation,
                                     GeodeticCurveType curveType)
```
Returns a geometry object that represents a buffer around the given geometry, calculated using a geodetic curve.
Geodesic buffers account for the actual shape of the Earth. Distances are calculated between points on a curved surface (the geoid) as opposed to points on a flat surface (the Cartesian plane).
Negative distance can be used to create a buffer inside a Polygon or an Envelope. Using a negative buffer distance will shrink geometry's boundary by the distance specified. Note that if the negative buffer distance is large enough, the geometry may collapse to an empty polygon.

Parameters:

geometry - the geometry to buffer

distance - the buffer distance for the geometry

distanceUnit - the unit of measurement for distance

maxDeviation - the maximum deviation between points

curveType - the type of geodetic curve to use

Returns:

a polygon that represents a buffer at the desired distance around the given geometry

Throws:

IllegalArgumentException - if geometry, distanceUnit or curveType is null

ArcGISRuntimeException - if the spatial reference of geometry is null

Since:

100.1.0

bufferGeodetic
```
public static List<Polygon> bufferGeodetic(Iterable<Geometry> geometries,
                                           Iterable<Double> distances,
                                           LinearUnit distanceUnit,
                                           double maxDeviation,
                                           GeodeticCurveType curveType,
                                           boolean unionResult)
```
Creates a buffer or buffers relative to a collection of geometries, basing calculations on a geodesic curve. The geometries must have consistent, non-null spatial references.
Geodesic buffers account for the actual shape of the Earth. Distances are calculated between points on a curved surface (the geoid) as opposed to points on a flat surface (the Cartesian plane).
Negative distance can be used to create buffers inside polygons. Using a negative buffer distance will shrink polygons' boundaries by the distance specified. Note that if the negative buffer distance is large enough, polygons may collapse to empty geometries.

Parameters:

geometries - the geometries to buffer

distances - the buffer distances for the geometries. If the number of distances is fewer than the number of geometries, the last distance value is used for the rest of the geometries.

distanceUnit - the unit of measurement for distances

maxDeviation - the maximum deviation between points

curveType - the type of geodetic curve to use

unionResult - true to return a single geometry that buffers all the input geometries; false to return a separate buffer for each of the input geometries

Returns:

an unmodifiable list of polygon geometries that represent a geodesic buffer at the desired distance(s) relative to the given geometries. If unionResult is true, there will be only one polygon in the resulting list. If geometries is an empty list, the returned list of polygons is also empty.

Throws:

IllegalArgumentException - if geometries, distanceUnit or curveType is null, or if distances is null or empty

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent

Since:

100.1.0

combineExtents
```
public static Envelope combineExtents(Geometry geometry1,
                                      Geometry geometry2)
```
Combines the extents of two given geometries. The input geometries must have consistent spatial references.
Supports true curves.

Parameters:

geometry1 - a geometry

geometry2 - another geometry

Returns:

an envelope that covers the extents of the input geometries

Throws:

IllegalArgumentException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.1.0

combineExtents
```
public static Envelope combineExtents(Iterable<Geometry> geometries)
```
Combines the extents of a collection of geometries. The input geometries must have consistent spatial references.
Supports true curves.

Parameters:

geometries - the input geometries

Returns:

an envelope that covers the extents of the input geometries

Throws:

IllegalArgumentException - if geometries is null or empty

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent

Since:

100.1.0

contains
```
public static boolean contains(Geometry container,
                               Geometry within)
```
Tests if geometry1 contains geometry2.
Supports true curves.

Parameters:

container - geometry that is tested for the "contains" relationship to within

within - geometry that is tested for the "within" relationship to container

Returns:

true if container contains within, false otherwise

Throws:

NullPointerException - if container or within is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

convexHull
```
public static Geometry convexHull(Geometry geometry)
```
Calculates the convex hull of the given geometry. The convex hull of a geometry is the minimal bounding geometry such that all outer angles are convex. If you imagine a rubber band stretched around the input geometry, the rubber band takes the shape of the convex hull.

Parameters:

geometry - the input geometry

Returns:

the convex hull of the given geometry

Throws:

IllegalArgumentException - if geometry is null

Since:

100.0.0

convexHull
```
public static List<Geometry> convexHull(Iterable<Geometry> geometries,
                                        boolean unionResult)
```
Calculates the convex hull or hulls of the geometries in the given collection. The geometries must have consistent spatial references. The convex hull of a geometry is the minimal bounding geometry such that all outer angles are convex. If you imagine a rubber band stretched around the input geometry, the rubber band takes the shape of the convex hull.

Parameters:

geometries - the input geometries

unionResult - true to return a single convex hull that encloses all the input geometries, false to return a separate convex hull for each of the input geometries

Returns:

an unmodifiable list containing either a single geometry or one geometry per input geometry, depending on the value of unionResult

Throws:

IllegalArgumentException - if geometries is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent

Since:

100.1.0

crosses
```
public static boolean crosses(Geometry geometry1,
                              Geometry geometry2)
```
Tests if geometry1 crosses geometry2.
This method returns true if an intersection results in a geometry whose dimension is one less than the maximum dimension of the two source geometries and the intersection set is interior to both source geometries. This method only returns true for the following combinations of geometries: Multipoint/Polygon, Multipoint/Polyline, Polyline/Polyline, and Polyline/Polygon comparisons.
Supports true curves.

Parameters:

geometry1 - one of the two geometries

geometry2 - the other geometry

Returns:

true if geometry1 crosses geometry2, false otherwise

Throws:

IllegalArgumentException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

cut
```
public static List<Geometry> cut(Geometry geometry,
                                 Polyline cutter)
```
Cuts geometry with cutter.
The cutter and geometry's spatial references must match.
When cutting a Polyline, all left cuts will be grouped together in the first Geometry, right cuts and co-incident cuts are grouped in the second Geometry, and each undefined cut, along with any uncut parts, are output as separate Polylines. A touch is considered to be a cut.
When cutting a Polygon, all left cuts are grouped in the first Geometry, all right cuts are in the second Geometry, and each undefined cut, along with any left-over parts after cutting, are output as a separate Geometry.
If there were no cuts then an empty collection will be returned.
If the left or right cut does not exist, the returned Geometry will be empty for this type of cut. An undefined cut will only be produced if a left cut or right cut was produced, and there was a part left over after cutting or a cut is bounded to the left and right of the cutter.

Parameters:

geometry - geometry to cut

cutter - polyline that cuts the geometry

Returns:

collection of geometries after cut

Throws:

IllegalArgumentException - if geometry or cutter is null

Since:

100.0.0

densify
```
public static Geometry densify(Geometry geometry,
                               double maxSegmentLength)
```
Densifies the input geometry by inserting additional vertices along the geometry at an interval defined by maxSegmentLength. Additional vertices are not inserted on segments of the input Polyline or Polygon that are shorter than maxSegmentLength.
Supports true curves as input, producing a densified curve as output where applicable.

Parameters:

geometry - a Polyline or Polygonto densify

maxSegmentLength - The maximum distance between vertices when the input geometry is densified. The linear unit is assumed to be that of the input geometry's spatial reference (decimal degrees for a geometry with a geographic spatial reference, meters for geometry with a Mercator spatial reference, and so on). Use SpatialReference.getUnit() to determine the unit used by the spatial reference.

Returns:

the densified geometry

Throws:

IllegalArgumentException - if geometry is null

Since:

100.0.0

densifyGeodetic
```
public static Geometry densifyGeodetic(Geometry geometry,
                                       double maxSegmentLength,
                                       LinearUnit lengthUnit,
                                       GeodeticCurveType curveType)
```
Densifies the input geometry by creating additional vertices along the geometry, using a geodesic curve.

Parameters:

geometry - geometry to densify

maxSegmentLength - the maximum distance between vertices when the input geometry is densified. Must be a positive value.

lengthUnit - unit of measure for maxSegmentLength. If null, defaults to linear unit of Id LinearUnitId.METERS.

curveType - type of geodetic curve to calculate

Returns:

the geodesic densified geometry

Throws:

IllegalArgumentException - if geometry or curveType is null

ArcGISRuntimeException - if the spatial reference of geometry is null

Since:

100.0.0

difference
```
public static Geometry difference(Geometry geometry1,
                                  Geometry geometry2)
```
Constructs the set-theoretic difference between two geometries. This will return a geometry consisting of the parts of geometry1 that are not in geometry2.
This method performs a spatial subtraction from the two input geometries. This means that the order of the two input geometry arguments of the difference method will have different results if they are switched. Think of the difference equation as:

A (Difference) B = C B (Difference) A = D
See symmetricDifference(Geometry, Geometry) to get the parts that are in either geometry, but not in both.
This method supports true curves.

Parameters:

geometry1 - first geometry

geometry2 - second geometry

Returns:

new geometry object that represents the difference of the two given input geometries

Throws:

NullPointerException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

disjoint
```
public static boolean disjoint(Geometry geometry1,
                               Geometry geometry2)
```
Tests whether two geometries are disjoint.
Supports true curves.

Parameters:

geometry1 - geometry1 one of the two geometries

geometry2 - geometry2 the other geometry

Returns:

true if geometry1 and geometry2 do not intersect/overlap, false otherwise

Throws:

IllegalArgumentException - if geometry1 or geometry2 are null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

distanceBetween
```
public static double distanceBetween(Geometry geometry1,
                                     Geometry geometry2)
```
Measures the simple planar distance between two geometries. This is a planar measurement using 2D Cartesian mathematics to calculate the distance in the same coordinate space as the inputs. Use distanceGeodetic(Point, Point, LinearUnit, AngularUnit, GeodeticCurveType) for a geodetic measurement of distance.
This distance calculation is based upon the SpatialReference of the input geometries. In general, planar measurements of distance and area can be extremely inaccurate if using an unsuitable spatial reference. Distortion may be negligible, however, for large scale maps (small areas) that use a suitable map projection. Ensure that you understand the potential for error with the geometry's spatial reference.
If you need to calculate more accurate results, do one of the following:
- Use a different spatial reference.
- Use the geodetic equivalent: distanceGeodetic(Point, Point, LinearUnit, AngularUnit, GeodeticCurveType).
See https://developers.arcgis.com/documentation/spatial-references/ for more information about spatial references.
Parameters:

geometry1 - first geometry

geometry2 - second geometry

Returns:

the distance between the two geometries in the same units as the geometry's spatial reference

Throws:

NullPointerException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

See Also:

distanceGeodetic(Point, Point, LinearUnit, AngularUnit, GeodeticCurveType)

distanceGeodetic
```
public static GeodeticDistanceResult distanceGeodetic(Point point1,
                                                      Point point2,
                                                      LinearUnit distanceUnit,
                                                      AngularUnit azimuthUnit,
                                                      GeodeticCurveType curveType)
```
Calculates the distance between two Points, returning the result in the given linear unit of measurement. The distance is calculated by accounting for the curvature of the earth's surface, using the given geodetic curve type. Use this method as an alternative to the distanceBetween(Geometry, Geometry) method for points that have a geographic spatial reference. The returned result includes additional information about the azimuths between the input points, in the given angular units.

Parameters:

point1 - the Point to calculate distance from

point2 - the Point to calculate distance to

distanceUnit - the linear unit of measurement for the returned result

azimuthUnit - the angular unit of measurement for the returned result

curveType - the type of geodetic curve between the two points to use to calculate distance

Returns:

the calculated geodetic distance, and other information resulting from the measurement

Throws:

IllegalArgumentException - if any of the arguments is null

ArcGISRuntimeException - if point1 and point2 have different spatial references

Since:

100.0.0

moveGeodetic
```
public static List<Point> moveGeodetic(List<Point> points,
                                       double distance,
                                       LinearUnit distanceUnit,
                                       double azimuth,
                                       AngularUnit azimuthUnit,
                                       GeodeticCurveType curveType)
```
Returns a List of Points, moved by the given distance at the given azimuth (angle) from the given input List of Points. The distance is calculated by accounting for the curvature of the earth's surface, using the given geodetic curve type. Specifying a negative distance moves points in the opposite direction from azimuth.
Each Point in the input list of Points must have the same SpatialReference. The returned unmodifiable collection is in the same order as the input, but with new Points at their destination locations.

Parameters:

points - the points to use as the starting locations for the returned points

distance - the distance to move the points

distanceUnit - the unit of measure of distance. If null, LinearUnitId.METERS will be used.

azimuth - the azimuth angle of the direction for the points

azimuthUnit - the angular unit of measure of azimuth. If null, AngularUnitId.DEGREES will be used.

curveType - the type of geodetic curve to move the points along

Returns:

an unmodifiable List of new Points, moved by the given distance from the input points

Throws:

IllegalArgumentException - if points or curveType is null

ArcGISRuntimeException - if the spatial references of the input points are inconsistent or null

Since:

100.0.0

moveGeodetic
```
public static Point moveGeodetic(Point point,
                                 double distance,
                                 LinearUnit distanceUnit,
                                 double azimuth,
                                 AngularUnit azimuthUnit,
                                 GeodeticCurveType curveType)
```
Returns a new Point, moved by the given distance at the given azimuth (angle) from the given input Point. The distance is calculated by accounting for the curvature of the earth's surface, using the given geodetic curve type.

Parameters:

point - the point to use as starting location for the returned point

distance - the distance to move the points

distanceUnit - the unit of measure of distance. If null, LinearUnitId.METERS will be used.

azimuth - the azimuth (angle) of the direction of movement

azimuthUnit - the angular unit of measure of azimuth. If null, AngularUnitId.DEGREES will be used.

curveType - the type of geodetic curve to move the point along

Returns:

a new Point moved by the given distance from the input point

Throws:

IllegalArgumentException - if point or curveType is null

ArcGISRuntimeException - if point spatial reference is null

Since:

100.0.0

ellipseGeodesic
```
public static Geometry ellipseGeodesic(GeodesicEllipseParameters parameters)
```
Calculates a geodesic ellipse (or geodesic circle, if semiAxis1Length = semiAxis2Length) centered on a specific point. If this method is used to generate a polygon or a polyline, the result may have more than one part depending on the size of the ellipse and its position relative to the horizon of the coordinate system. When the method generates a polyline or a multipoint, the result vertices lie on the boundary of the ellipse. When a polygon is generated, the interior of the polygon is the interior of the ellipse.
If the smaller axis is zero, the ellipse will degenerate to a line segment, a point, or an empty geometry (depending on the larger axis and output type). Otherwise, if GeodesicEllipseParameters.getMaxPointCount() < 10, the number of vertices will default to 10.

Parameters:

parameters - various options needed to construct the ellipse

Returns:

a geodesic ellipse centered on a specific point

Throws:

IllegalArgumentException - if parameters is null

IllegalArgumentException - if the GeodesicEllipseParameters.getGeometryType() is not one of GeometryType.MULTIPOINT, GeometryType.POLYLINE, GeometryType.POLYGON

ArcGISRuntimeException - if parameters is not valid

Since:

100.0.0

equals
```
public static boolean equals(Geometry geometry1,
                             Geometry geometry2)
```
Tests if two geometries are equal. Does not take coordinate order into account.
For the strictest equals comparisons of two geometries (which do take into account coordinate order) use:
Supports true curves.
Parameters:

geometry1 - does this geometry equal geometry2?

geometry2 - does this geometry equal geometry1?

Returns:

true if the two geometries are equal, false otherwise

Throws:

NullPointerException - if geometry1 or geometry2 is null

Since:

100.0.0

extend
```
public static Polyline extend(Polyline polyline,
                              Polyline extender,
                              ExtendOptions... extendOptions)
```
Extends a polyline using a polyline as the extender.
The output polyline will have the first and last segment of each path extended to the extender if the segments can be interpolated to intersect the extender. In the case that the segments can be extended to multiple segments of the extender, the shortest extension is chosen. Only end points for paths that are not shared by the end points of other paths will be extended.

Parameters:

polyline - the polyline to be extended

extender - the polyline to extend to

extendOptions - an array or sequence of one or more ExtendOptions, indicating the type of extend operation to perform

Returns:

the extended polyline, or null if polyline cannot be extended by extender

Throws:

IllegalArgumentException - if polyline, extender or extendOptions is null, or extendOptions is empty

IllegalArgumentException - if multiple extendOptions are passed and they contain values that are incompatible with each other

Since:

100.1.0

fractionAlong
```
public static double fractionAlong(Polyline line,
                                   Point point,
                                   double tolerance)
```
Finds the location on the line nearest the point, expressed as the fraction along the line's total geodesic length, if the point is within the specified distance from the the closest location on the line. The line and point must have consistent spatial references.
This method supports true curves.

Parameters:

line - the line to locate the point's distance along its length

point - the point to locate

tolerance - maximum distance that a point is allowed to be from the line, in the units of the SpatialReference. If the tolerance is -1, the fraction of the closest location on the line is always returned as long as the point lies between the two ends of the polyline. If the distance from the point to the closest location on the line is greater than the tolerance, or the tolerance is -1 and the point does not lie between the two ends of the polyline, NaN is returned.

Returns:

the length along the line nearest the input point, expressed as the fraction of the line's length between 0.0 and 1.0, or NAN if the point is outside the tolerance

Throws:

IllegalArgumentException - if the line or point parameters are null

Since:

100.6.0

generalize
```
public static Geometry generalize(Geometry geometry,
                                  double maxDeviation,
                                  boolean removeDegenerateParts)
```
Generalizes the given geometry by removing vertices, based on the Douglas-Peucker algorithm. Point and Multipoint geometries cannot be generalized.
Supports true curves as input, producing a densified curve as output where applicable.

Parameters:

geometry - geometry to generalize

maxDeviation - the maximum distance that the generalized geometry can deviate from the original, in the same units as the geometry's spatial reference system

removeDegenerateParts - if true, degenerate parts of the resulting geometry that are undesired for drawing will be removed

Returns:

geometry that represents the generalization of the input geometry

Throws:

IllegalArgumentException - if geometry is null

Since:

100.0.0

intersection
```
public static Geometry intersection(Geometry geometry1,
                                    Geometry geometry2)
```
Calculates the intersection of two geometries.
The result has the same dimensionality as the lower dimensionality of the two intersecting geometries. Returns an empty geometry if there is no intersection with this dimensionality. For example, the intersection of two polygons (geometries with area, so they have dimensionality of 2) or, say, a polygon and an envelope (also an area) is a polygon. Similarly, the intersection of a polyline (a line, so dimensionality of 1) and another polyline is always a polyline. Therefore when computing the intersection of polylines, this function does not return points where they cross, but rather lines of overlap. If there are no lines of overlap, an empty polyline is returned even if the input lines cross. To obtain all intersections, irrespective of dimensionality, see intersections(Geometry, Geometry).
Supports true curves.

Parameters:

geometry1 - first geometry

geometry2 - second geometry

Returns:

geometry object that represents the intersection of the given geometries

Throws:

NullPointerException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

intersections

public static List<Geometry> intersections(Geometry geometry1,
                                           Geometry geometry2)

Calculates the intersections of two geometries.

The returned list contains one geometry of each dimension for which there are intersections. For example, if both inputs are polylines, the list will contain at most two geometries: the first a multipoint containing the points at which the lines cross, and the second a polyline containing the lines of overlap. If a crossing point lies within a line of overlap, only the line of overlap is present - the result set is not self-intersecting. If there are no crossing points or there are no lines of overlap, the respective geometry will not be present in the list. If the input geometries do not intersect, the list will be empty. The table below shows, for each combination of pairs of input geometry types, the types of geometry that will be contained within the list if there are intersections of that type.

Set of potential output geometry types for pairs of input geometry types:
Input type	Point/Multipoint	Polyline	Polygon/Envelope
Point/Multipoint	Multipoint	Multipoint	Multipoint
Polyline	Multipoint	Multipoint, Polyline	Multipoint, Polyline
Polygon/Envelope	Multipoint	Multipoint, Polyline	Multipoint, Polyline, Polygon

The geometries in the returned list are sorted by ascending dimensionality, for example multipoint (dimension 0) then polyline (dimension 1) then polygon (dimension 2) for the intersection of two geometries with area that have intersections of those types.

Supports true curves.

Parameters:: geometry1 - first geometry; geometry2 - second geometry
Returns:: an unmodifiable list containing geometry objects that represent the intersection of the given geometries
Throws:: IllegalArgumentException - if geometry1 or geometry2 is null; ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null
Since:: 100.1.0

intersects
```
public static boolean intersects(Geometry geometry1,
                                 Geometry geometry2)
```
Tests if two geometries intersect.
Supports true curves.

Parameters:

geometry1 - first geometry

geometry2 - second geometry

Returns:

true if the two geometries intersect, false otherwise

Throws:

NullPointerException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

labelPoint
```
public static Point labelPoint(Polygon polygon)
```
Calculates an interior point for the given polygon. This point can be used by clients to place a label for the polygon.
This method supports true curves.

Parameters:

polygon - polygon to calculate the interior point of

Returns:

a point that represents the interior point for the given polygon

Throws:

IllegalArgumentException - if polygon is null

Since:

100.0.0

length
```
public static double length(Polyline polyline)
```
Calculates the length of the given polyline. This is a planar measurement using 2D Cartesian mathematics to compute the length. Use lengthGeodetic(Geometry, LinearUnit, GeodeticCurveType) for geodetic measurement.
This length calculation is based upon the SpatialReference of the input geometry. Although some projections are better than others for preserving distance, it will always be distorted in some areas of the map. Distortion may be negligible for large scale maps (small areas) that use a suitable map projection. Make sure you know your data and spatial reference if accurate measurements are required. For more accurate results, consider using the lengthGeodetic(Geometry, LinearUnit, GeodeticCurveType) operation.
Supports true curves.

Parameters:

polyline - polyline to calculate the length of

Returns:

the length of the given geometry in the same units as the polyline's spatial reference

Throws:

NullPointerException - if polyline is null

Since:

100.0.0

lengthGeodetic
```
public static double lengthGeodetic(Geometry geometry,
                                    LinearUnit lengthUnit,
                                    GeodeticCurveType curveType)
```
Calculates the geodetic length of the geometry. Geodesic length is calculated using only the vertices of the geometry and defines the lines between vertices as geodesic segments independent of the actual shape of the geometry. A geodesic segment is the shortest path between two points on an ellipsoid.
Supports true curves, calculating the results by densifying curves.

Parameters:

geometry - geometry to calculate the geodetic length of

lengthUnit - unit of measure for the return value. If null, defaults to linear unit of Id LinearUnitId.METERS.

curveType - geodetic curve type to calculate the length

Returns:

the geodetic length of the given geometry

Throws:

IllegalArgumentException - if geometry or curveType is null

ArcGISRuntimeException - if the spatial reference of geometry is null

Since:

100.0.0

nearestCoordinate
```
public static ProximityResult nearestCoordinate(Geometry geometry,
                                                Point point)
```
Determines the nearest point in the input geometry to the input point using a simple planar measurement.
Input geometry of type Envelope is not supported. To find the nearest coordinate on an Envelope, convert it to a Polygon first.
Planar measurements of distance and area can be extremely inaccurate if using an unsuitable spatial reference. Ensure that you understand the potential for error with the geometry's spatial reference. If you need to calculate more accurate results consider using a different spatial reference, or using the geodetic equivalent, nearestCoordinateGeodetic(Geometry, Point, double, LinearUnit).
If the specified geometry is a polyline or polygon, the nearest coordinate is the closest point on or along the line segment that comprises the geometry; it may not necessarily be the closest vertex of the line segment. If you want to obtain the closest vertex in the polyline or polygon use the nearestVertex(Geometry, Point) method instead.
Supports true curves.

Parameters:

geometry - geometry on which to find the nearest coordinate. Envelope is not supported

point - point to calculate the nearest coordinate from

Returns:

a ProximityResult containing the results of the operation. This is null if the input geometry is empty. ProximityResult.getDistance() is zero if the point lies inside an input polygon or polyline.

Throws:

IllegalArgumentException - if geometry or point is null

IllegalArgumentException - if geometry is of type Envelope

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

nearestCoordinateGeodetic
```
public static ProximityResult nearestCoordinateGeodetic(Geometry geometry,
                                                        Point point,
                                                        double maxDeviation,
                                                        LinearUnit deviationUnit)
```
Determines the nearest point in the input geometry to the input point, by using a shape preserving geodesic approximation of the input geometry.
All geometry types are supported for the geometry parameter. Supports true curves.

Parameters:

geometry - a geometry object on which to calculate the nearest coordinate to the point parameter

point - the point from which to calculate the nearest coordinate on the geometry parameter

maxDeviation - the maximum distance that the geodesic geometry can deviate from the original, in the units of the deviationUnit parameter. This value controls the error of calculation. If <= zero, or if NAN, deviation defaults to 0.01 meters.

deviationUnit - the unit of measure for the maxDeviation parameter. If null, the units of maxDeviation are assumed to be meters.

Returns:

a ProximityResult containing the results of the operation, where the ProximityResult.getDistance() is returned in meters. Returns null if the input geometry is empty. ProximityResult.getDistance() is zero if the point lies inside an input polygon, polyline, or envelope.

Throws:

IllegalArgumentException - if geometry is null

IllegalArgumentException - if point is null

Since:

100.14.0

See Also:

nearestCoordinate(Geometry, Point)

nearestVertex
```
public static ProximityResult nearestVertex(Geometry geometry,
                                            Point point)
```
Returns a ProximityResult that describes the nearest vertex in the input geometry to the input point.
Input geometry of type Envelope is not supported. To find the nearest vertex on an Envelope, convert it to a Polygon first.
If the specified geometry is a polyline or polygon, the nearest vertex is the closest end point of the line segment that comprises the geometry; it may not necessarily be the closest point along the line segment. If you want to obtain the closest point in the polyline or polygon use the nearestCoordinate(Geometry, Point) method instead.
Input geometries with true curves (where Geometry.hasCurves() is true) are supported, although curve segments do not affect the return value.

Parameters:

geometry - geometry on which to find the nearest vertex. Envelope is not supported

point - point to calculate the nearest vertex from

Returns:

result containing the nearest vertex

Throws:

IllegalArgumentException - if geometry or point is null

IllegalArgumentException - if geometry is of type Envelope

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

normalizeCentralMeridian
```
public static Geometry normalizeCentralMeridian(Geometry geometry)
```
Returns a copy of the input geometry that does not intersect the antimeridian. You may wish to use this method to normalize geometries before passing them to methods that require coordinates within the spatial reference domain, for example geodatabase editing methods or geocoding services.
The returned geometry may have multiple parts, in order to ensure each part does not intersect the antimeridian. The returned geometry is the same type as the input geometry, except in the case of an Envelope in which case the returned geometry is a Polygon.
This method supports true curves.

Parameters:

geometry - the geometry to be normalized

Returns:

the normalized geometry

Throws:

NullPointerException - if geometry is null

Since:

100.0.0

offset
```
public static Geometry offset(Geometry geometry,
                              double distance,
                              GeometryOffsetType offsetType,
                              double bevelRatio,
                              double flattenError)
```
Creates an offset version of the input geometry.
The offset operation creates a geometry that is a constant distance from the input geometry. It is similar to buffering, but produces a one sided result. If offset distance is greater than 0, then the offset geometry is constructed to the right of the oriented input geometry, otherwise it is constructed to the left. For a simple polygon, the orientation of outer rings is clockwise and for inner rings it is counterclockwise. So the "right side" of a simple polygon is always its inside. The bevelRatio is multiplied by the offset distance and the result determines how far a mitered offset intersection can be from the input curve before it is beveled.

Parameters:

geometry - geometry to create the offset from

distance - offset distance for the geometry result. If distance is greater than 0, then the offset geometry is constructed to the right of the input geometry, otherwise it is constructed to the left

offsetType - offset type of the geometry result

bevelRatio - the ratio used to produce a bevel join instead of a miter join (used only when the offset type is GeometryOffsetType.MITERED)

flattenError - the maximum distance of the resulting segments compared to the true circular arc (used only when the offset type is GeometryOffsetType.ROUNDED). The algorithm never produces more than around 180 vertices for each round join.

Returns:

an offset version of the input geometry

Throws:

IllegalArgumentException - if geometry or offsetType is null

Since:

100.0.0

overlaps
```
public static boolean overlaps(Geometry geometry1,
                               Geometry geometry2)
```
Tests if two geometries overlap.
Supports true curves.

Parameters:

geometry1 - one of the two geometries

geometry2 - the other geometry

Returns:

true if the two geometries overlap, false otherwise

Throws:

IllegalArgumentException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

project
```
public static Geometry project(Geometry geometry,
                               SpatialReference spatialReference)
```
Projects the given geometry from its current spatial reference system into the given spatial reference system, using the default geographic transformation.
A default best-choice DatumTransformation is applied to the project operation. You can use the TransformationCatalog.getTransformation(SpatialReference, SpatialReference) method to find out which transformation is used by default for the given spatial references. To control the specific transformation used, use the project(Geometry, SpatialReference, DatumTransformation) overload.
If the geometry parameter has z values, those z values will also be transformed, provided that both the SpatialReference of that geometry and the spatialReference parameter have a vertical coordinate system.
Supports true curves. Projecting curves located at poles and coordinate system horizons using ArcGIS Runtime may give results that differ slightly from other ArcGIS software because ArcGIS Runtime uses a different geometry projection function.

Parameters:

geometry - input geometry to project

spatialReference - the output spatial reference into which the geometry will be projected

Returns:

the geometry projected into the output spatial reference. If the input geometry has a null SpatialReference, no projection occurs; instead, this method returns an identical geometry that has the spatial reference specified by the spatialReference parameter.

Throws:

NullPointerException - if geometry or spatialReference is null

Since:

100.0.0

project
```
public static Geometry project(Geometry geometry,
                               SpatialReference spatialReference,
                               DatumTransformation datumTransformation)
```
Projects the given geometry from its current spatial reference system into the given output spatial reference system, applying the datum transformation provided.
Use this overload to project a geometry if the difference between the input geometry's SpatialReference and the output SpatialReference involves a change of datum, and you do not wish to use the default datum transformation used by project(Geometry, SpatialReference).
```
 // Create a geometry located in London, UK, with British National Grid spatial reference
 Point britishNationalGridPt = new Point(538985.355, 177329.516, SpatialReference.create(27700));
 // Create a GeographicTransformation with a single step using WKID for OSGB_1936_To_WGS_1984_NGA_7PAR transformation
 GeographicTransformation transform = GeographicTransformation.create(GeographicTransformationStep.create(108336));
 // Project the point to WGS84, using the transformation
 Point wgs84Pt = (Point) GeometryEngine.project(britishNationalGridPt, SpatialReferences.getWgs84(), transform);
 
```
Supports true curves. Projecting curves located at poles and coordinate system horizons using ArcGIS Runtime may give results that differ slightly from other ArcGIS software because ArcGIS Runtime uses a different geometry projection function.
Parameters:

geometry - the input geometry to project

spatialReference - the output spatial reference into which the geometry will be projected

datumTransformation - the datum transformation that describes how coordinates are converted from one coordinate system to another; if null, then the default transformation is used. Using a HorizontalVerticalTransformation here will also transform the z-values of the geometry, if (1) the geometry has z-values and (2) both the spatialReference parameter and the SpatialReference of the geometry parameter have a vertical coordinate system set.

Returns:

the geometry projected into the output spatial reference. If the input geometry has a null SpatialReference no projection occurs; instead, this method returns an identical geometry that has the spatial reference specified by the spatialReference parameter.

Throws:

IllegalArgumentException - if geometry or spatialReference is null

ArcGISRuntimeException - if the datumTransformation's DatumTransformation.isMissingProjectionEngineFiles() method returns true

Since:

100.2.0

relate
```
public static boolean relate(Geometry geometry1,
                             Geometry geometry2,
                             String relation)
```
Compares the spatial relationship of two geometries. Can compare interior, boundary and exterior of two geometries based on a DE-9IM encoded string.
This method supports true curves.

Parameters:

geometry1 - one of the two geometries

geometry2 - the other geometry

relation - the DE-9IM string to be evaluated. Strings such as "T*****FF*" are accepted.

Returns:

true if the two geometries are related by the given relation, false otherwise

Throws:

IllegalArgumentException - if geometry1 or geometry2 is null

IllegalArgumentException - if relation is null or empty

ArcGISRuntimeException - if relation is not valid

Since:

100.0.0

removeM
```
public static Geometry removeM(Geometry geometry)
```
Creates a copy of a geometry with its m values removed. If the given geometry has no m values, the given geometry itself is returned. The resulting geometry will have Geometry.hasM() false.
Supports true curves.

Parameters:

geometry - the input geometry

Returns:

a copy of the input geometry with its m values removed, or the input geometry itself if it already has no m values

Throws:

IllegalArgumentException - if geometry is null

Since:

100.1.0

removeZ
```
public static Geometry removeZ(Geometry geometry)
```
Creates a copy of a geometry with its z values removed. If the given geometry has no z values, the given geometry itself is returned. The resulting geometry will have Geometry.hasZ() false.
Supports true curves.

Parameters:

geometry - the input geometry

Returns:

a copy of the input geometry with its z values removed, or the input geometry itself if it already has no z values

Throws:

IllegalArgumentException - if geometry is null

Since:

100.1.0

removeZAndM
```
public static Geometry removeZAndM(Geometry geometry)
```
Creates a copy of a geometry with its z- and m values removed. If the given geometry has no z- or m values, the given geometry itself is returned. The resulting geometry will have Geometry.hasZ() and Geometry.hasM() false.
Supports true curves.

Parameters:

geometry - the input geometry

Returns:

a copy of the input geometry with its z- and m values removed, or the input geometry itself if it already has no z- or m values

Throws:

IllegalArgumentException - if geometry is null

Since:

100.1.0

reshape
```
public static Multipart reshape(Multipart geometry,
                                Polyline reshaper)
```
Reshapes a polygon or polyline using a single path polyline as the reshaper. The output geometry takes the shape of the input geometry where it first intersects the reshaper to the last intersection. The first and last intersection points of the reshaper are chosen closest to the end points of the reshaper in the case that multiple intersections are found. For polygons, only individual paths can be reshaped. However, polylines can be reshaped across paths.

Parameters:

geometry - the polygon or polyline to be reshaped

reshaper - the single path polyline reshaper

Returns:

the reshaped polygon or polyline, or null if the input geometry cannot be reshaped by the reshaper

Throws:

IllegalArgumentException - if geometry or reshaper is null

Since:

100.1.0

sectorGeodesic
```
public static Geometry sectorGeodesic(GeodesicSectorParameters parameters)
```
Creates a sector as a polygon, polyline or multipoint geometry. A geodesic sector is defined by a geodesic elliptical arc and two radii extending from the center point of the arc to the points where they each intersect the arc. The arc is a portion of an ellipse. The ellipse is defined by a center point, the lengths of its semi-major and semi-minor axes, and the direction of its semi-major axis. The first radius of the sector is defined by the start direction angle relative to the direction of the semi-major axis. The second radius is the sum of the start direction and the sector angle.

Parameters:

parameters - options for constructing the sector

Returns:

a geometry representing the geodesic sector

Throws:

IllegalArgumentException - if parameters is null

IllegalArgumentException - if the GeodesicEllipseParameters.getGeometryType() is not one of GeometryType.MULTIPOINT, GeometryType.POLYLINE, GeometryType.POLYGON

ArcGISRuntimeException - if parameters is not valid

Since:

100.0.0

setM
```
public static Geometry setM(Geometry geometry,
                            double m)
```
Creates a copy of a geometry with its m values set to the given value. If the given geometry already has m values, they will be replaced within the resulting geometry by the given m value. The resulting geometry will have Geometry.hasM() true.
Supports true curves.

Parameters:

geometry - the input geometry

m - the m value to set

Returns:

a copy of the input geometry with its m values set to the given value

Throws:

IllegalArgumentException - if geometry is null

Since:

100.1.0

setZ
```
public static Geometry setZ(Geometry geometry,
                            double z)
```
Creates a copy of a geometry with its z values set to the given value. If the given geometry already has z values, they will be replaced within the resulting geometry by the given z value. The resulting geometry will have Geometry.hasZ() true.
Supports true curves.

Parameters:

geometry - the input geometry

z - the z value to set

Returns:

a copy of the input geometry with its z values set to the given value

Throws:

IllegalArgumentException - if geometry is null

Since:

100.1.0

setZAndM
```
public static Geometry setZAndM(Geometry geometry,
                                double z,
                                double m)
```
Creates a copy of a geometry with its z- and m values set to the given values. If the given geometry already has z- or m values, they will be replaced within the resulting geometry by the given values. The resulting geometry will have Geometry.hasZ() and Geometry.hasM() true.
Supports true curves.

Parameters:

geometry - the input geometry

z - the z value to set

m - the m value to set

Returns:

a copy of the input geometry with its z- and m values set to the given values

Throws:

IllegalArgumentException - if geometry is null

Since:

100.1.0

simplify
```
public static Geometry simplify(Geometry geometry)
```
Simplifies the given geometry to make it topologically consistent according to its geometry type. For instance, it rectifies polygons that may be self-intersecting, or contain incorrect ring orientations.
Many of the methods in the geometry engine only work on geometry that is simple, and only simple geometries can be stored in a geodatabase.
Supports true curves.

Parameters:

geometry - geometry to simplify

Returns:

simplified geometry

Throws:

NullPointerException - if geometry is null

Since:

100.0.0

symmetricDifference
```
public static Geometry symmetricDifference(Geometry geometry1,
                                           Geometry geometry2)
```
Calculates the symmetric difference (exclusive or) of the two geometries.

Parameters:

geometry1 - one of the two geometries

geometry2 - the other geometry

Returns:

the symmetric difference of the two geometries

Throws:

IllegalArgumentException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

touches
```
public static boolean touches(Geometry geometry1,
                              Geometry geometry2)
```
Test if the two geometries touch on their borders.
Supports true curves.

Parameters:

geometry1 - does this geometry touch geometry2?

geometry2 - does this geometry touch geometry1?

Returns:

true if the two geometries have at least one boundary point in common, but no interior points. False otherwise.

Throws:

NullPointerException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

union
```
public static Geometry union(Geometry geometry1,
                             Geometry geometry2)
```
Calculates the union of the two geometries.
Returns those parts of the two input geometries which overlap, combined into a single geometry. This means that the order of the input parameters of the GeometryEngine.Intersection is irrelevant. Think of the union equation as:

A (Union) B = C B (Union) A = C
Supports true curves.

Parameters:

geometry1 - first geometry

geometry2 - second geometry

Returns:

the union of the two geometries

Throws:

NullPointerException - if geometry1 or geometry2 is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

union
```
public static Geometry union(Iterable<Geometry> geometries)
```
Calculates the union of a collection of geometries.
If the collection contains geometries of differing dimensionality, returns the union of the subset of geometries with the highest dimensionality. For example, given a collection of polygons, polylines and points, returns the union of the polygons.
The input geometries must have consistent spatial references.

Parameters:

geometries - the input geometries

Returns:

the union of the input geometries

Throws:

IllegalArgumentException - if geometries is null or empty

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent

Since:

100.1.0

within
```
public static boolean within(Geometry within,
                             Geometry container)
```
Tests if within is within container.
Supports true curves.

Parameters:

within - geometry that is tested for the "within" relationship to container

container - geometry that is tested for the "contains" relationship to within

Returns:

true if within lies in the interior of the container, false otherwise. The boundary and interior of within is not allowed to intersect the exterior of the container and within may not equal the container.

Throws:

NullPointerException - if within or container is null

ArcGISRuntimeException - if the spatial references of the input geometries are inconsistent or null

Since:

100.0.0

clip
```
public static Geometry clip(Geometry geometry,
                            Envelope envelope)
```
Returns a geometry created by clipping the given Geometry with the given Envelope. If no part of the Geometry lies within the Envelope, then the returned Geometry will be empty.
Supports true curves.

Parameters:

geometry - the geometry to be clipped by the given envelope

envelope - the extent at which to clip the given geometry

Returns:

the clipped geometry

Throws:

IllegalArgumentException - if geometry or envelope is null

ArcGISRuntimeException - if geometry and envelope arguments have different spatial references

Since:

100.0.0

See Also:

intersection(Geometry, Geometry)

isSimple
```
public static boolean isSimple(Geometry geometry)
```
Indicates if this Geometry is topologically simple (in other words, is topologically correct).
Point geometries are always simple.
Multipoint geometries cannot have any points with exactly equal x and y values.
Polylines can have no degenerate segments.
For Polygons, the following must be true for the polygon to be considered simple:
- Exterior rings must be clockwise, and holes must be counterclockwise.
- Rings can touch other rings only at a finite number of vertices.
- Rings can be self tangent only at a finite number of vertices.
- Segments with a length less than zero are not allowed.
- Each path must contain at least three non-coincident vertices.
- Paths must not be empty.
Supports true curves.
Parameters:

geometry - the geometry to be tested if it is simple

Returns:

true if the provided geometry is simple, false otherwise

Throws:

IllegalArgumentException - if the geometry is null

Since:

100.0.0

createPointAlong

public static Point createPointAlong(Polyline polyline,
                                     double distance)

Calculates the point at the given distance along the line.

If distance is less than or equal to zero, the point returned is coincident with the start of the line. If the distance is greater than or equal to the line's length, the point returned is coincident with the end of the line. If the line has multiple parts (notes: the gap does not count as part of line, it is ignored), and the distance falls exactly on a boundary between two parts, the returned point will be coincident with either the end of one part or the start of the next – which is undetermined.

This method supports true curves.

As an example to illustrate the returned point you expect to obtain, suppose that you have a polyline with two parts, one is from [0, 0] to [10, 0], the other from [30, 0] to [50, 0], here is the table for the returned point at a given distance:


Distance	Point returned	Comments
0	[0, 0]	Start of part 0
5	[5, 0]	Midpoint of part 0
10	[10, 0]	End of part 0
10	[30, 0]	OR start of part 1
20	[40, 0]	Midpoint of part 1
30	[50, 0]	end of part 1

Parameters:: polyline - the polyline from which the point is created; distance - the distance along the polyline, in the units of the polyline, where to create the point
Returns:: the point at the given distance along the line
Throws:: IllegalArgumentException - if polyline is null
Since:: 100.3.0

Class GeometryEngine

Method Summary

Methods inherited from class java.lang.Object

Method Detail

area

area

areaGeodetic

autoComplete

boundary

buffer

buffer

bufferGeodetic

bufferGeodetic

combineExtents

combineExtents

contains

convexHull

convexHull

crosses

cut

densify

densifyGeodetic

difference

disjoint

distanceBetween

distanceGeodetic

moveGeodetic

moveGeodetic

ellipseGeodesic

equals

extend

fractionAlong

generalize

intersection

intersections

intersects

labelPoint

length

lengthGeodetic

nearestCoordinate

nearestCoordinateGeodetic

nearestVertex

normalizeCentralMeridian

offset

overlaps

project

project

relate

removeM

removeZ

removeZAndM

reshape

sectorGeodesic

setM

setZ

setZAndM

simplify

symmetricDifference

touches

union

union

within

clip

isSimple

createPointAlong