arcgis.geometry.functions module¶

The Functions module is used to take Geometry types as parameters and return Geometry type results.

areas_and_lengths¶

arcgis.geometry.functions.areas_and_lengths(polygons, length_unit, area_unit, calculation_type, spatial_ref=4326, gis=None, future=False)¶

The areas_and_lengths function calculates areas and perimeter lengths for each Polygon specified in the input array.

Keys	Description
polygons	The array of `Polygon` whose areas and lengths are to be computed.
length_unit	The length unit in which the perimeters of polygons will be calculated. If `calculation_type` is planar, then `length_unit` can be any esriUnits constant. If `length_unit` is not specified, the units are derived from `spatial_ref`. If `calculationType` is not planar, then `length_unit` must be a linear esriUnits constant, such as esriSRUnit_Meter or esriSRUnit_SurveyMile. If `length_unit` is not specified, the units are meters. For a list of valid units, see esriSRUnitType Constants and esriSRUnit2Type Constant.
area_unit	The area unit in which areas of polygons will be calculated. If calculation_type is planar, then area_unit can be any esriUnits constant. If `area_unit` is not specified, the units are derived from `spatial_ref`. If `calculation_type` is not planar, then `area_unit` must be a linear esriUnits constant such as esriSRUnit_Meter or esriSRUnit_SurveyMile. If area_unit is not specified, then the units are meters. For a list of valid units, see esriSRUnitType Constants and esriSRUnit2Type constant. The list of valid esriAreaUnits constants include, esriSquareInches \| esriSquareFeet \| esriSquareYards \| esriAcres \| esriSquareMiles \| esriSquareMillimeters \| esriSquareCentimeters \| esriSquareDecimeters \| esriSquareMeters \| esriAres \| esriHectares \| esriSquareKilometers.
calculation_type	The type defined for the area and length calculation of the input geometries. The type can be one of the following values: 1. planar - Planar measurements use 2D Euclidean distance to calculate area and length. This should only be used if the area or length needs to be calculated in the given `SpatialReference`. Otherwise, use `preserveShape`. 2. geodesic - Use this type if you want to calculate an area or length using only the vertices of the `Polygon` and define the lines between the points as geodesic segments independent of the actual shape of the `Polygon`. A geodesic segment is the shortest path between two points on an ellipsoid. 3. preserveShape - This type calculates the area or length of the geometry on the surface of the Earth ellipsoid. The shape of the geometry in its coordinate system is preserved.
future	A required Boolean. This operation determines if the job is run asynchronously or not.

>>> geom = Geometry({
>>>   "rings" : [[[-97.06138,32.837],[-97.06133,32.836],[-97.06124,32.834],[-97.06127,32.832],
>>>               [-97.06138,32.837]],[[-97.06326,32.759],[-97.06298,32.755],[-97.06153,32.749],
>>>               [-97.06326,32.759]]],
>>>   "spatialReference" : {"wkid" : 4326}
>>>                 })
>>> geom.areas_and_lengths(polygons =[polygon1, polygon2,...],
                           length_unit = "esriMeters",
                           area_unit = "esriSquareMeters",
                           calculation_type = "planar",
                           future = True)

Returns: JSON as dictionary

auto_complete¶

arcgis.geometry.functions.auto_complete(polygons=None, polylines=None, spatial_ref=None, gis=None, future=False)¶

The auto_complete function simplifies the process of constructing new Polygon objects that are adjacent to other polygons. It constructs polygons that fill in the gaps between existing polygons and a set of Polyline objects.

Keys	Description
polygons	An array of `Polygon` objects
polylines	An List of `Polyline` objects
spatial_ref	A `SpatialReference` of the input geometries WKID
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: A Polygon object

buffer¶

arcgis.geometry.functions.buffer(geometries, in_sr, distances, unit, out_sr=None, buffer_sr=None, union_results=None, geodesic=None, gis=None, future=False)¶

The buffer function is performed on a geometry service resource The result of this function is a buffered Polygon at the specified distances for the input Geometry array.

Note

The options are available to union buffers and to use geodesic distance.

Keys	Description
geometries	The array of geometries to be buffered
in_sr	The well-known ID of the `SpatialReference` or a spatial reference JSON object for the input geometries.
distances	The distances that each of the input geometries is buffered.
unit	The units for calculating each buffer distance. If unit is not specified, the units are derived from `bufferSR`. If `bufferSR` is not specified, the units are derived from `in_sr`.
out_sr	The well-known ID of the `SpatialReference` or a spatial reference JSON object for the output geometries.
buffer_sr	The well-known ID of the `SpatialReference` or a spatial reference JSON object for the buffer geometries.
union_results	A boolean. If True, all geometries buffered at a given distance are unioned into a single (gis,possibly multipart) `Polygon`, and the unioned geometry is placed in the output array. The default is False.
geodesic	Set geodesic to true to buffer the input geometries using geodesic distance. Geodesic distance is the shortest path between two points along the ellipsoid of the earth. If geodesic is set to False, the 2D Euclidean distance is used to buffer the input geometries. Note The default value depends on the geometry type, unit and bufferSR.
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

>>> geom = Geometry({
>>>   "rings" : [[[-97.06138,32.837],[-97.06133,32.836],[-97.06124,32.834],[-97.06127,32.832],
>>>               [-97.06138,32.837]],[[-97.06326,32.759],[-97.06298,32.755],[-97.06153,32.749],
>>>               [-97.06326,32.759]]],
>>>   "spatialReference" : {"wkid" : 4326}
>>>                 })
>>> new_poly = geom.buffer(geometries =[geom1, geom2,...],
                           in_sr = "wkid_in",
                           unit = "esriMeters",
                           out_sr = "wkid_out",
                           buffer_sr = "wkid_buffer",
                           union_results =True,
                           geodesic = True,
                           future = True)
>>> new_poly.type
    "POLYGON"

Returns: A Polygon object

convex_hull¶

arcgis.geometry.functions.convex_hull(geometries, spatial_ref=None, gis=None, future=False)¶

The convex_hull function is performed on a Geometry service resource. It returns the convex hull of the input geometry. The input geometry can be a Point, MultiPoint, Polyline , or Polygon.

Note

The convex hull is typically a polygon but can also be a polyline or point in degenerate cases.

Keys	Description
geometries	An array of `Point`, `MultiPoint`, `Polyline`, or `Polygon` objects. The structure of each geometry in the array is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: The convex hull of the Geometry object

cut¶

arcgis.geometry.functions.cut(cutter, target, spatial_ref=None, gis=None, future=False)¶

The cut function is performed on a Geometry service resource. This function splits the target Polyline or Polygon where it is crossed by the cutter polyline.

Note

At 10.1 and later, this function calls simplify on the input cutter and target geometries.

Keys	Description
cutter	The `Polyline` that will be used to divide the target into pieces where it crosses the target.The spatial reference of the polylines is specified by `spatial_ref`. Note The structure of the polyline is the same as the structure of the JSON polyline objects returned by the ArcGIS REST API.
geometries	The array of `Polyline` or `Polygon` to be cut. The structure of the geometry is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API. The spatial reference of the target geometry array is specified by spatial_ref.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or a JSON object for the output geometry
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: A List of Geometry objects

densify¶

arcgis.geometry.functions.densify(geometries, spatial_ref, max_segment_length, length_unit, geodesic=False, gis=None, future=False)¶

The densify function is performed using the GIS geometry engine. This function densifies Geometry objects by plotting Point objects between existing vertices.

Keys	Description
geometries	An array of `Point`, `MultiPoint`, `Polyline`, or `Polygon` objects. The structure of each geometry in the array is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API.
spatial_ref	The `well-known ID` or a spatial reference JSON object for the input `Polyline` object. Note For a list of valid WKID values, see Projected coordinate systems and Geographic coordinate systems.
max_segment_len	All segments longer than `maxSegmentLength` are replaced with sequences of lines no longer than `max_segment_length`.
length_unit	The length unit of `max_segment_length`. If `geodesic` is set to false, then the units are derived from `spatial_ref`, and `length_unit` is ignored. If `geodesic` is set to true, then `length_unit` must be a linear unit. In a case where `length_unit` is not specified and `spatial_ref` is a PCS, the units are derived from `spatial_ref`. In a case where `length_unit` is not specified and `spatial_ref` is a GCS, then the units are meters.
geodesic	If geodesic is set to true, then geodesic distance is used to calculate max_segment_length. Geodesic distance is the shortest path between two points along the ellipsoid of the earth. If geodesic is set to false, then 2D Euclidean distance is used to calculate max_segment_length. The default is false.
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

>>> geom = Geometry({
>>>   "rings" : [[[-97.06138,32.837],[-97.06133,32.836],[-97.06124,32.834],[-97.06127,32.832],
>>>               [-97.06138,32.837]],[[-97.06326,32.759],[-97.06298,32.755],[-97.06153,32.749],
>>>               [-97.06326,32.759]]],
>>>   "spatialReference" : {"wkid" : 4326}
>>>                 })
>>> new_geom = geom.densify(geometries =[geom1, geom2,...],
                            spatial_ref = "wkid",
                            max_segment_length = 100.0,
                            length_unit = "esriMeters",
                            geodesic = True,
                            future = True)
>>> new_geom.type
    "GEOMETRY"

Returns: A Geometry object

difference¶

arcgis.geometry.functions.difference(geometries, spatial_ref, geometry, gis=None, future=False)¶

The difference function is performed on a geometry service resource. This function constructs the set-theoretic difference between each element of an array of geometries and another geometry the so-called difference geometry. In other words, let B be the difference geometry. For each geometry, A, in the input geometry array, it constructs A-B.

Keys	Description
geometries	An array of `Point`, `MultiPoint`, `Polyline`, or `Polygon` objects. The structure of each geometry in the array is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API.
geometry	A single geometry of any type and of a dimension equal to or greater than the elements of geometries. The structure of geometry is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API. The use of simple syntax is not supported.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: A Geometry object

distance¶

arcgis.geometry.functions.distance(spatial_ref, geometry1, geometry2, distance_unit='', geodesic=False, gis=None, future=False)¶

The distance function is performed on a geometry service resource. It reports the 2D Euclidean or geodesic distance between the two Geometry objects.

Returns: The 2D or geodesic distance between the two Geometry objects

find_transformation¶

arcgis.geometry.functions.find_transformation(in_sr, out_sr, extent_of_interest=None, num_of_results=1, gis=None, future=False)¶

The find_transformations function is performed on a Geometry service resource. This function returns a list of applicable geographic transformations you should use when projecting geometries from the input SpatialReference to the output SpatialReference. The transformations are in JSON format and are returned in order of most applicable to least applicable. Recall that a geographic transformation is not needed when the input and output spatial references have the same underlying geographic coordinate systems. In this case, findTransformations returns an empty list.

Note

Every returned geographic transformation is a forward transformation meaning that it can be used as-is to project from the input spatial reference to the output spatial reference. In the case where a predefined transformation needs to be applied in the reverse direction, it is returned as a forward composite transformation containing one transformation and a transformForward element with a value of false.

Keys	Description
in_sr	The well-known ID of the `SpatialReference` or a spatial reference JSON object for the input geometries.
out_sr	The well-known ID of the `SpatialReference` or a spatial reference JSON object for the output geometries.
ext_of_interest	The bounding box of the area of interest specified as a JSON envelope.If provided, the extent of interest is used to return the most applicable geographic transformations for the area. Note If a `SpatialReference` is not included in the JSON envelope, the `in_sr` is used for the envelope.
num_of_results	The number of geographic transformations to return. The default value is 1. Note If `num_of_results` has a value of -1, all applicable transformations are returned.
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: A List of geographic transformations

from_geo_coordinate_string¶

arcgis.geometry.functions.from_geo_coordinate_string(spatial_ref, strings, conversion_type, conversion_mode=None, gis=None, future=False)¶

The from_geo_coordinate_string function is performed on a Geometry service resource. The function converts an array of well-known strings into xy-coordinates based on the conversion type and SpatialReference supplied by the user. An optional conversion mode parameter is available for some conversion types. See to_geo_coordinate_strings for more information on the opposite conversion.

Keys	Description
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
strings	An array of strings formatted as specified by conversion_type. Syntax: [<string1>,…,<stringN>]
conversion-type	The conversion type of the input strings. Note Valid conversion types are: MGRS - Military Grid Reference System USNG - United States National Grid UTM - Universal Transverse Mercator GeoRef - World Geographic Reference System GARS - Global Area Reference System DMS - Degree Minute Second DDM - Degree Decimal Minute DD - Decimal Degree
conversion_mode	Conversion options for MGRS, UTM and GARS conversion types. Note Valid conversion modes for MGRS are: mgrsDefault - Default. Uses the spheroid from the given spatial reference. mgrsNewStyle - Treats all spheroids as new, like WGS 1984. The 80 degree longitude falls into Zone 60. mgrsOldStyle - Treats all spheroids as old, like Bessel 1841. The 180 degree longitude falls into Zone 60. mgrsNewWith180InZone01 - Same as mgrsNewStyle except the 180 degree longitude falls into Zone 01 mgrsOldWith180InZone01 - Same as mgrsOldStyle except the 180 degree longitude falls into Zone 01 Note Valid conversion modes for UTM are: utmDefault - Default. No options. utmNorthSouth - Uses north/south latitude indicators instead of zone numbers - Non-standard. Default is recommended
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

>>> geom = Geometry({
>>>   "rings" : [[[-97.06138,32.837],[-97.06133,32.836],[-97.06124,32.834],[-97.06127,32.832],
>>>               [-97.06138,32.837]],[[-97.06326,32.759],[-97.06298,32.755],[-97.06153,32.749],
>>>               [-97.06326,32.759]]],
>>>   "spatialReference" : {"wkid" : 4326}
>>>                 })
>>> coords = from_geo_coordinate_string(spatial_ref = "wkid",
                                strings = ["01N AA 66021 00000","11S NT 00000 62155", "31U BT 94071 65288"]
                                conversion_type = "MGRS",
                                conversion_mode = "mgrs_default",
                                future = True)
>>> coords
    [[x1,y1], [x2,y2], [x3,y3]]

Returns: An array of (x,y) coordinates

generalize¶

arcgis.geometry.functions.generalize(spatial_ref, geometries, max_deviation, deviation_unit, gis=None, future=False)¶

The generalize function is performed on a Geometry service resource. The generalize function simplifies the input geometries using the Douglas-Peucker algorithm with a specified maximum deviation distance.

Note

The output geometries will contain a subset of the original input vertices.

Keys	Description
geometries	The array `Geometry` objects to be generalized.
max_deviation	`max_deviation` sets the maximum allowable offset, which will determine the degree of simplification. This value limits the distance the output geometry can differ from the input geometry.
deviation_unit	If `geodesic` is set to true, then the geodesic distance between the `geometry1` and `geometry2` geometries is returned. Geodesic distance is the shortest path between two points along the ellipsoid of the earth. If `geodesic` is set to false or not specified, the planar distance is returned. The default value is false.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: An array of the simplified Geometry objects

intersect¶

arcgis.geometry.functions.intersect(spatial_ref, geometries, geometry, gis=None, future=False)¶

The intersect function is performed on a Geometry service resource. This function constructs the set-theoretic intersection between an array of geometries and another geometry.

Note

The dimension of each resultant geometry is the minimum dimension of the input geometry in the geometries array and the other geometry specified by the geometry parameter.

Keys	Description
geometries	An array of `Point`, `MultiPoint`, `Polyline`, or `Polygon` objects. The structure of each geometry in the array is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API.
geometry	A single `Geometry` of any type and of a dimension equal to or greater than the elements of geometries. The structure of geometry is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API. The use of simple syntax is not supported.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: The set-theoretic dimension between Geometry objects

label_points¶

arcgis.geometry.functions.label_points(spatial_ref, polygons, gis=None, future=False)¶

The label_points function is performed on a Geometry service resource. The labelPoints function calculates an interior Point for each Polygon specified in the input array. These interior points can be used by clients for labeling the polygons.

Keys	Description
polygons	An array of `Polygon` objects whose label `Point` objects are to be computed. The spatial reference of the polygons is specified by `spatial_ref`.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: An array of Point objects

lengths¶

arcgis.geometry.functions.lengths(spatial_ref, polylines, length_unit, calculation_type, gis=None, future=False)¶

The lengths function is performed on a Geometry service resource. This function calculates the` 2D Euclidean` or geodesic lengths of each Polyline specified in the input array.

Keys	Description
polylines	The array of `Polyline` whose lengths are to be computed.
length_unit	The length unit in which the length of `Polyline` will be calculated. If `calculation_type` is planar, then `length_unit` can be any esriUnits constant. If `lengthUnit` is not specified, the units are derived from `spatial_ref`. If `calculationType` is not planar, then lengthUnit must be a linear esriUnits constant, such as esriSRUnit_Meter or esriSRUnit_SurveyMile. If `length_unit` is not specified, the units are meters. For a list of valid units, see esriSRUnitType Constants and esriSRUnit2Type Constant.
calculation_type	The type defined for the length calculation of the input geometries. The type can be one of the following values: 1. planar - Planar measurements use 2D Euclidean distance to calculate area and length. This should only be used if the area or length needs to be calculated in the given `SpatialReference`. Otherwise, use `preserveShape`. 2. geodesic - Use this type if you want to calculate an area or length using only the vertices of the `Polygon` and define the lines between the points as geodesic segments independent of the actual shape of the `Polygon`. A geodesic segment is the shortest path between two points on an ellipsoid. 3. preserveShape - This type calculates the area or length of the geometry on the surface of the Earth ellipsoid. The shape of the geometry in its coordinate system is preserved.
future	A required Boolean. This operation determines if the job is run asynchronously or not.

Returns: A list of floats of 2D-Euclidean or Geodesic lengths

offset¶

arcgis.geometry.functions.offset(geometries, offset_distance, offset_unit, offset_how='esriGeometryOffsetRounded', bevel_ratio=10, simplify_result=False, spatial_ref=None, gis=None, future=False)¶

The offset function is performed on a Geometry service resource. This function constructs geometries that are offset from the given input geometries. If the offset parameter is positive, the constructed offset will be on the right side of the geometry. Left side offsets are constructed with negative parameters.

Note

Tracing the geometry from its first vertex to the last will give you a direction along the geometry. It is to the right and left perspective of this direction that the positive and negative parameters will dictate where the offset is constructed. In these terms, it is simple to infer where the offset of even horizontal geometries will be constructed.

Keys	Description
geometries	An array of `Point`, `MultiPoint`, `Polyline`, or `Polygon` objects. The structure of each geometry in the array is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API.
offset_distance	Specifies the distance for constructing an offset based on the input geometries. Note If the `offset_distance` parameter is positive, the constructed offset will be on the right side of the curve. Left-side offsets are constructed with negative values.
offset_unit	A unit for offset distance. If a unit is not specified, the units are derived from `spatial_ref`.
offset_how	The `offset_how` parameter determines how outer corners between segments are handled. The three options are as follows: `esriGeometryOffsetRounded` - Rounds the corner between extended offsets. `esriGeometryOffsetBevelled` - Squares off the corner after a given ratio distance. 3. `esriGeometryOffsetMitered` - Attempts to allow extended offsets to naturally intersect, but if that intersection occurs too far from the corner, the corner is eventually bevelled off at a fixed distance.
bevel_ratio	`bevel_ratio` is multiplied by the `offset_distance`, and the result determines how far a mitered offset intersection can be located before it is bevelled. When mitered is specified, bevel_ratio is ignored and 10 is used internally. When bevelled is specified, 1.1 will be used if bevel_ratio is not specified. `bevel_ratio` is ignored for rounded offset.
simplify_result	if `simplify_result` is set to true, then self intersecting loops will be removed from the result offset geometries. The default is false.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

>>> geom = Geometry({
>>>   "rings" : [[[-97.06138,32.837],[-97.06133,32.836],[-97.06124,32.834],[-97.06127,32.832],
>>>               [-97.06138,32.837]],[[-97.06326,32.759],[-97.06298,32.755],[-97.06153,32.749],
>>>               [-97.06326,32.759]]],
>>>   "spatialReference" : {"wkid" : 4326}
>>>                 })
>>> new_geom = offset(geometries = [geom1,geom2,...],
                      offset_distance = 100,
                      offset_unit = "esriMeters",
                      offset_how = "esriGeometryOffsetRounded",
                      bevel_ratio = 0,
                      simplify_result = True
                      spatial_ref = "wkid",
                      future = True)
>>> new_geom.type
    arcgis.geometry.Geometry

Returns: A Geometry object

project¶

arcgis.geometry.functions.project(geometries, in_sr, out_sr, transformation='', transform_forward=False, gis=None, future=False)¶

The project function is performed on a Geometry service resource. This function projects an array of input geometries from the input SpatialReference to the output SpatialReference

Keys	Description
geometries	An array of `Point`, `MultiPoint`, `Polyline`, or `Polygon` objects. The structure of each geometry in the array is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API.
in_sr	The well-known ID of the `SpatialReference` or a spatial reference JSON object for the input geometries.
out_sr	The well-known ID of the `SpatialReference` or a spatial reference JSON object for the output geometries.
transformations	The WKID or a JSON object specifying the geographic transformation (gis,also known as datum transformation) to be applied to the projected geometries. Note A transformation is needed only if the output `SpatialReference` contains a different geographic coordinate system than the input spatial reference.
transformforward	A Boolean value indicating whether or not to transform forward. The forward or reverse direction of transformation is implied in the name of the transformation. If transformation is specified, a value for the `transform_Forward` parameter must also be specified. The default value is false.
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

#Usage Example

>>> input_geom = [{"x": -17568824.55, "y": 2428377.35}, {"x": -17568456.88, "y": 2428431.352}]
>>> result = project(geometries = input_geom,
                     in_sr = 3857,
                     out_sr = 4326)
    [{"x": -157.82343617279275, "y": 21.305781607280093}, {"x": -157.8201333369876, "y": 21.306233559873714}]

Returns: A list of Geometry objects in the out_sr coordinate system

relation¶

arcgis.geometry.functions.relation(geometries1, geometries2, spatial_ref, spatial_relation='esriGeometryRelationIntersection', relation_param='', gis=None, future=False)¶

The relation function is performed on a Geometry service resource. This function determines the pairs of geometries from the input geometry arrays that participate in the specified spatial relation. Both arrays are assumed to be in the spatial reference specified by spatial_ref, which is a required parameter. Geometry types cannot be mixed within an array.

Note

The relations are evaluated in 2D. In other words, z coordinates are not used.

Keys	Description
geometry1	The first array of `Geometry` objects to compute relations.
geometry2	The second array of `Geometry` objects to compute relations.
relation_param	The Shape Comparison Language string to be evaluated.
spatial_relation	The spatial relationship to be tested between the two input geometry arrays. Values: esriGeometryRelationCross \| esriGeometryRelationDisjoint \| esriGeometryRelationIn \| esriGeometryRelationInteriorIntersection \| esriGeometryRelationIntersection \| esriGeometryRelationLineCoincidence \| esriGeometryRelationLineTouch \| esriGeometryRelationOverlap \| esriGeometryRelationPointTouch \| esriGeometryRelationTouch \| esriGeometryRelationWithin \| esriGeometryRelationRelation
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

>>> geom = Geometry({
        >>>   "rings" : [[[-97.06138,32.837],[-97.06133,32.836],[-97.06124,32.834],[-97.06127,32.832],
        >>>               [-97.06138,32.837]],[[-97.06326,32.759],[-97.06298,32.755],[-97.06153,32.749],
        >>>               [-97.06326,32.759]]],
        >>>   "spatialReference" : {"wkid" : 4326}
        >>>                 })
        >>> new_geom = relation(geometry1 = [geom1,geom2,...],
                              geometry2 = [geom21,geom22,..],
                              relation_param = "relationParameter",
                              spatial_relation = "esriGeometryRelationPointTouch"
                              spatial_ref = "wkid",
                              future = True)
        >>> new_geom
            [[geom1,geom22], [geom2,geom21]]

Returns: An array of paired Geometry objects

reshape¶

arcgis.geometry.functions.reshape(spatial_ref, target, reshaper, gis=None, future=False)¶

The reshape function is performed on a Geometry service resource. It reshapes a Polyline or Polygon feature by constructing a polyline over the feature. The feature takes the shape of the reshaper polyline from the first place the reshaper intersects the feature to the last.

Keys	Description
target	The `Polyline` or `Polygon` to be reshaped.
reshaper	The single-part `Polyline` that does the reshaping.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or a JSON object for the input geometry
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: A reshaped Polyline or Polygon object

simplify¶

arcgis.geometry.functions.simplify(spatial_ref, geometries, gis=None, future=False)¶

The simplify function is performed on a Geometry service resource. simplify permanently alters the input geometry so that the geometry becomes topologically consistent. This resource applies the ArcGIS simplify function to each geometry in the input array.

Keys	Description
geometries	An array of `Point`, `MultiPoint`, `Polyline`, or `Polygon` objects. The structure of each geometry in the array is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: An array of Geometry objects

to_geo_coordinate_string¶

arcgis.geometry.functions.to_geo_coordinate_string(spatial_ref, coordinates, conversion_type, conversion_mode='mgrsDefault', num_of_digits=None, rounding=True, add_spaces=True, gis=None, future=False)¶

The to_geo_coordinate_string function is performed on a Geometry service resource. The function converts an array of xy-coordinates into well-known strings based on the conversion type and SpatialReference supplied by the User. Optional parameters are available for some conversion types. See from_geo_coordinate_strings for more information on the opposite conversion.

Note

If an optional parameter is not applicable for a particular conversion type, but a value is supplied for that parameter, the value will be ignored.

Keys	Description
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
coordinates	An array of xy-coordinates in JSON format to be converted. Syntax: [[x1,y2],…[xN,yN]]
conversion-type	The conversion type of the input strings. Note Valid conversion types are: MGRS - Military Grid Reference System USNG - United States National Grid UTM - Universal Transverse Mercator GeoRef - World Geographic Reference System GARS - Global Area Reference System DMS - Degree Minute Second DDM - Degree Decimal Minute DD - Decimal Degree
conversion_mode	Conversion options for MGRS, UTM and GARS conversion types. Note Valid conversion modes for MGRS are: mgrsDefault - Default. Uses the spheroid from the given spatial reference. mgrsNewStyle - Treats all spheroids as new, like WGS 1984. The 80 degree longitude falls into Zone 60. mgrsOldStyle - Treats all spheroids as old, like Bessel 1841. The 180 degree longitude falls into Zone 60. mgrsNewWith180InZone01 - Same as mgrsNewStyle except the 180 degree longitude falls into Zone 01 mgrsOldWith180InZone01 - Same as mgrsOldStyle except the 180 degree longitude falls into Zone 01 Note Valid conversion modes for UTM are: utmDefault - Default. No options. utmNorthSouth - Uses north/south latitude indicators instead of zone numbers - Non-standard. Default is recommended
num_of_digits	The number of digits to output for each of the numerical portions in the string. The default value for `num_of_digits` varies depending on `conversion_type`.
rounding	If `True`, then numeric portions of the string are rounded to the nearest whole magnitude as specified by num_of_digits. Otherwise, numeric portions of the string are truncated. The rounding parameter applies only to conversion types MGRS, USNG and GeoRef. The default value is `True`.
addSpaces	If `True`, then spaces are added between components of the string. The `addSpaces` parameter applies only to conversion types MGRS, USNG and UTM. The default value for MGRS is `False`, while the default value for both USNG and UTM is `True`.
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

>>> geom = Geometry({
>>>   "rings" : [[[-97.06138,32.837],[-97.06133,32.836],[-97.06124,32.834],[-97.06127,32.832],
>>>               [-97.06138,32.837]],[[-97.06326,32.759],[-97.06298,32.755],[-97.06153,32.749],
>>>               [-97.06326,32.759]]],
>>>   "spatialReference" : {"wkid" : 4326}
>>>                 })
>>> strings = from_geo_coordinate_string(spatial_ref = "wkid",
                                coordinates = [[x1,y1], [x2,y2], [x3,y3]]
                                conversion_type = "MGRS",
                                conversion_mode = "mgrs_default",
                                future = True)
>>> strings
    ["01N AA 66021 00000","11S NT 00000 62155", "31U BT 94071 65288"]

Returns: An array of Strings

trim_extend¶

arcgis.geometry.functions.trim_extend(spatial_ref, polylines, trim_extend_to, extend_how=0, gis=None, future=False)¶

The trim_extend function is performed on a Geometry service resource. This function trims or extends each Polyline specified in the input array, using the user-specified guide polylines.

Note

When trimming features, the part to the left of the oriented cutting line is preserved in the output, and the other part is discarded. An empty Polyline is added to the output array if the corresponding input polyline is neither cut nor extended.

Keys	Description
polylines	An array of `Polyline` objects to trim or extend
trim_extend_to	A `Polyline` that is used as a guide for trimming or extending input polylines.
extend_how	A flag that is used along with the trimExtend function. `0` - By default, an extension considers both ends of a path. The old ends remain, and new points are added to the extended ends. The new points have attributes that are extrapolated from adjacent existing segments. `1` - If an extension is performed at an end, relocate the end point to the new position instead of leaving the old point and adding a new point at the new position. `2` - If an extension is performed at an end, do not extrapolate the end-segment’s attributes for the new point. Instead, make its attributes the same as the current end. Incompatible with esriNoAttributes. `4` - If an extension is performed at an end, do not extrapolate the end-segment’s attributes for the new point. Instead, make its attributes empty. Incompatible with esriKeepAttributes. `8` - Do not extend the ‘from’ end of any path. `16` - Do not extend the ‘to’ end of any path.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

>>> geom = Geometry({
>>>   "rings" : [[[-97.06138,32.837],[-97.06133,32.836],[-97.06124,32.834],[-97.06127,32.832],
>>>               [-97.06138,32.837]],[[-97.06326,32.759],[-97.06298,32.755],[-97.06153,32.749],
>>>               [-97.06326,32.759]]],
>>>   "spatialReference" : {"wkid" : 4326}
>>>                 })
>>> polylines_arr = trim_extends(polylines = [polyline1,polyline2, ...],
                                 trim_extend_to = polyline_trimmer
                                 extend_how = 2,
                                 spatial_ref = "wkid",
                                 future = True)
>>> polyline_arr
    [polyline1, polyline2,...]

Returns: An array of Polyline objects

union¶

arcgis.geometry.functions.union(spatial_ref, geometries, gis=None, future=False)¶

The union function is performed on a Geometry service resource. This function constructs the set-theoretic union of the geometries in the input array.

Note

All inputs must be of the same type.

Keys	Description
geometries	An array of `Point`, `MultiPoint`, `Polyline`, or `Polygon` objects. The structure of each geometry in the array is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API.
spatial_ref	A `SpatialReference` of the input geometries Well-Known ID or JSON object
future	An optional Boolean. This operation determines if the job is run asynchronously or not.

Returns: The set-theoretic union of the Geometry objects