geometryEngineAsync

方法概述

方法详细说明

buffer(geometry, distance, unit, unionResults){Promise<(Polygon|Polygon[])>}

在输入几何周围的指定距离处创建平面 (或欧氏) 缓冲区面。

GeometryEngine 具有两种用于缓冲客户端几何的方法：buffer 和 geodesicBuffer。请谨慎决定使用哪种方法。作为一般规则，使用 geodesicBuffer 的前提是输入几何的空间参考为 WGS84 (wkid: 4326) 或 Web Mercator。仅在尝试使用除 Web Mercator 以外的 缓冲几何时才使用缓冲区 (此方法)。如果您需要使用除 WGS84 (wkid: 4326)，请使用 geometryService.buffer()。

参数

geometry Geometry|Geometry[] 缓冲区输入的几何。geometry 和 distance 参数必须指定为两个数组或两个非数组。请勿将一个参数指定为数组，另一个指定为非数组。

distance Number|Number[] 用于缓冲的指定距离。geometry 和 distance 参数必须指定为两个数组或两个非数组。请勿将一个参数指定为数组，另一个指定为非数组。当使用几何数组作为输入时，几何数组的长度不必等于 distance 数组的长度。例如，如果您传递一个包含四个几何的数组：[g1, g2, g3, g4] 和一个距离数组：[d1]，则所有四个几何都将由单个距离值缓冲。如果改为使用包含三个距离的数组：[d1, d2, d3]，g1 将按 d1 缓冲，g2 将按 d2 缓冲，g3 和 g4 将按 d3 缓冲。几何数组的值将与距离数组中的值一一匹配，直到达到距离数组的最终值，在这种情况下，该值将应用于剩余的几何。

unit LinearUnits optional 距离的测量单位。默认为输入几何的单位。

unionResults Boolean optional 默认值： false 确定输出几何是否应联合为单个多边形。

返回

类型	描述
Promise<(Polygon|Polygon[])>	解析后，响应是生成的缓冲区。如果将几何数组用作输入，则结果将为数组。如果将单个几何输入到函数中，则该多边形将是单个面。

另请参阅

• geometryEngine.buffer()
• geometryEngine.geodesicBuffer()
• geometryEngineAsync.geodesicBuffer()

示例

const pointBuffer = await geometryEngineAsync.buffer(point, 1000, "feet");

clip(geometry, envelope){Promise<Geometry>}

基于目标几何按包络矩形计算裁剪几何。

参数

geometry Geometry 要修剪的几何图形。

envelope Extent 用于裁剪的包络。

返回

类型	描述
Promise<Geometry>	解析后，响应是剪裁的几何。

另请参阅

• geometryEngine.clip()

示例

// returns a new geometry of a polygon clipped by the views extent
const clippedGeometry = await geometryEngineAsync.clip(boundaryPolygon, view.extent);

contains(containerGeometry, insideGeometry){Promise<boolean>}

指示一个几何图形是否包含另一个几何图形。

参数

containerGeometry Geometry 测试几何与其他几何的“包含”关系。将此几何视为 insideGeometry 的潜在“容器”。

insideGeometry Geometry 测试与 containerGeometry 的“within”关系的几何。

返回

类型	描述
Promise<boolean>	如果 containerGeometry 包含 insideGeometry，则响应为 true。

另请参阅

• geometryEngine.contains()

示例

// returns true or false for one geometry containing another
const isContained = await geometryEngineAsync.contains(extent, boundaryPolygon);

convexHull(geometry, merge){Promise<(Geometry|Geometry[])>}

计算一个或多个几何的凸包。凸包是包围一组几何体或顶点的最小凸多边形。输入可以是单个几何 (如折线) 或任何几何类型的数组。凸包通常是多边形，但在退化情况下也可以是折线或点。

参数

geometry Geometry|Geometry[] 用于计算凸包的输入几何。如果指定了数组，则输入数组可以包含各种几何类型。提供数组时，输出也将是数组。

merge Boolean optional 默认值： false 指示是否将输出合并到单个几何 (通常是多边形) 中。

返回

类型	描述
Promise<(Geometry|Geometry[])>	解析为输入几何的凸包。这通常是一个多边形，但也可以是一条折线 (如果输入是一组点或形成一条直线的折线) 或一个点 (在降维的情况下)。

另请参阅

• geometryEngine.convexHull()

示例

// returns the convex hull of a multipoint as a single polygon
const hull = await geometryEngineAsync.convexHull(multipoint);

// returns the convex hull of an array of points as a single polygon
const [ hull ] = await geometryEngineAsync.convexHull([ pointA, pointB, pointC ], true);

// returns the convex hull for each input line geometry as three polygons
const hulls = await geometryEngineAsync.convexHull([ lineA, lineB, lineC ]);

// returns the convex hull for all input line geometries as a single polygon
const [ hull ] = await geometryEngineAsync.convexHull([ lineA, lineB, lineC ], true);

// returns the convex hull for all input geometries as a single polygon
const [ hull ] = await geometryEngineAsync.convexHull([ point, line, polygon ], true);

crosses(geometry1, geometry2){Promise<boolean>}

指示一个几何图形是否与另一几何图形相交。

参数

geometry1 Geometry 要交叉的几何。

geometry2 Geometry 正在交叉的几何。

返回

类型	描述
Promise<boolean>	如果 geometry1 与 geometry2 交叉，则响应为 true。

另请参阅

• geometryEngine.crosses()

示例

// returns true or false if a line crosses a polygon
const isCrossed = await geometryEngineAsync.crosses(boundaryPolygon, polyline);

cut(geometry, cutter){Promise<Geometry[]>}

在与剪切折线相交处拆分输入折线或多边形。对于折线，所有左侧切割都将分组在第一个几何中。右侧切割和重合切割将分组在第二个几何中，每个未定义的切割以及任何未切割的部分都将作为单独的折线输出。对于多边形，所有左侧切割都将分组在第一个多边形中，所有右侧切割都将分组在第二个多边形中，每个未定义的切割以及切割后的任何剩余部分都将作为单独的多边形输出。如果没有返回切割，则数组将为空。只有在产生了左侧切割或右侧切割，并且在切割后有剩余部分时，或者切割被限定在切割器的左右两侧时，才会产生未定义的切割。

参数

geometry Geometry 要进行剪切的几何。

cutter Polyline 用于剪切几何的折线。

返回

类型	描述
Promise<Geometry[]>	解析后，响应是通过使用切割器切割输入几何而创建的几何数组。

另请参阅

• geometryEngine.cut()

示例

// returns array of cut geometries
const geometries = await geometryEngineAsync.cut(boundaryPolygon, polyline);

densify(geometry, maxSegmentLength, maxSegmentLengthUnit){Promise<Geometry>}

通过在现有折点之间绘制点来增密几何。

参数

geometry Geometry 要进行增密的几何。

maxSegmentLength Number 允许的最大线段长度。必须是正值。

maxSegmentLengthUnit LinearUnits optional maxSegmentLength 的度量单位。默认为输入几何的单位。

返回

类型	描述
Promise<Geometry>	解析后，响应是增密的几何。

另请参阅

• geometryEngine.densify()

• geodesicDensify()

示例

// Returns a densified geometry
const geometry = await geometryEngineAsync.densify(boundaryPolygon, 25);

difference(inputGeometry, subtractor){Promise<Geometry>}

创建两个几何图形的差异。结果几何是 inputGeometry 不在 subtractor 中的部分。subtractor 的维度必须等于或大于 inputGeometry 的维度。

参数

inputGeometry Geometry|Geometry[] 要从中减去的输入几何。

subtractor Geometry 从 inputGeometry 中减去的几何。

返回

类型	描述
Promise<Geometry>	解析后，响应是 inputGeometry 的几何减去 subtractor 几何。

另请参阅

• geometryEngine.difference()

示例

// Creates a new geometry based on the
// difference of the two
const geometry = await geometryEngineAsync.difference(boundaryPolygon, buffers);

disjoint(geometry1, geometry2){Promise<boolean>}

指示一个几何是否与另一几何分离 (不以任何方式相交)。

参数

geometry1 Geometry 测试基础几何与其他几何的 "disjoint” 关系。

geometry2 Geometry 测试比较几何与其他几何的 “disjoint” 关系。

返回

类型	描述
Promise<boolean>	解析时，如果 geometry1 和 geometry2 不相交 (不以任何方式相交)，则响应为 true。

另请参阅

• geometryEngine.disjoint()

示例

// returns true if a geometry is not contained in another.
// operates the opposite of contains
const isDisjointed = await geometryEngineAsync.disjoint(polygon, boundaryPolygon);

distance(geometry1, geometry2, distanceUnit){Promise<number>}

计算两个几何之间的最短平面距离。距离以 distanceUnit 指定的线性单位报告，如果 distanceUnit 为空，则以输入几何的 spatialReference 单位报告。

要计算两点之间的测地线距离，首先需使用两个兴趣点作为单条路径的起点和终点构造一条折线。然后使用该折线作为 geodesicLength() 方法的输入。

参数

geometry1 Geometry 第一个输入几何。

geometry2 Geometry 第二个输入几何。

distanceUnit LinearUnits optional 返回值的测量单位。默认为输入几何的单位。

返回

类型	描述
Promise<number>	解析后，响应为两个输入几何之间的距离。

另请参阅

• geometryEngine.distance()

示例

// returns numeric distance between two points
const totalDistance = await geometryEngineAsync.distance(point1, point2, "feet");

equals(geometry1, geometry2){Promise<boolean>}

指示两个几何是否相等。

参数

geometry1 Geometry 第一个输入几何。

geometry2 Geometry 第二个输入几何。

返回

类型	描述
Promise<boolean>	解析后，如果两个输入几何相等，则响应为 true。

另请参阅

• geometryEngine.equals()

示例

// returns true if two given geometries are equal
const isEqual = await geometryEngineAsync.equals(line1, line2);

extendedSpatialReferenceInfo(spatialReference){Promise<SpatialReferenceInfo>}

返回一个对象，其中包含有关输入空间参考的其他信息。

参数

spatialReference SpatialReference 输入空间参考。

返回

类型	描述
Promise<SpatialReferenceInfo>	解析为 SpatialReferenceInfo 对象。

另请参阅

• geometryEngine.extendedSpatialReferenceInfo()

flipHorizontal(geometry, flipOrigin){Promise<Geometry>}

在水平轴上翻转几何。可选择性地围绕一个点进行翻转。

参数

geometry Geometry 要进行翻转的输入几何。

flipOrigin Point optional 围绕该点翻转几何。默认为几何的质心。

返回

类型	描述
Promise<Geometry>	解析后，响应是翻转的几何图形。

另请参阅

• geometryEngine.flipHorizontal()

示例

// Returns a geometry flipped horizontally
const geometry = await geometryEngineAsync.flipHorizontal(boundaryPolygon);

flipVertical(geometry, flipOrigin){Promise<Geometry>}

在垂直轴上翻转几何。可选择性地围绕一个点进行翻转。

参数

geometry Geometry 要进行翻转的输入几何。

flipOrigin Point optional 围绕该点翻转几何。默认为几何的质心。

返回

类型	描述
Promise<Geometry>	解析后，响应是翻转的几何图形。

另请参阅

• geometryEngine.flipVertical()

示例

// Returns a geometry flipped vertically
const geometry = await geometryEngineAsync.flipVertical(boundaryPolygon);

generalize(geometry, maxDeviation, removeDegenerateParts, maxDeviationUnit){Promise<Geometry>}

对游标中的几何执行概化操作。点和多点几何保持不变。将包络转换为多边形，然后进行概化。

参数

geometry Geometry 要进行概化的输入几何。

maxDeviation Number 从概化几何到原始几何允许的最大偏差。

removeDegenerateParts Boolean optional 当为 true 时，几何的简化部分将从输出中移除 (可能不适合绘制)。

maxDeviationUnit LinearUnits optional maxDeviation 的测量单位。默认为输入几何的单位。

返回

类型	描述
Promise<Geometry>	解析后，响应是概化的几何。

另请参阅

• geometryEngine.generalize()

示例

// Returns a generalized geometry
const geometry = await geometryEngineAsync.generalize(boundaryPolygon, 2.5, true, "miles");

geodesicArea(geometry, unit){Promise<number>}

计算输入几何的面积。与 planarArea() 不同，geodesicArea 在执行此计算时会考虑地球的曲率。因此，当使用空间参考为 WGS84 (wkid: 4326) 或 Web Mercator 的输入几何时，最佳实践是使用 geodesicArea() 计算面积。如果输入几何具有 Web 墨卡托以外的投影坐标系，请改用 planarArea()。

此方法仅适用于 WGS84 (wkid: 4326) 和 Web Mercator 空间参考。

参数

geometry Polygon 输入面。

unit AreaUnits optional 返回值的测量单位。默认为输入几何的单位。

返回

类型	描述
Promise<number>	解析后，响应是输入几何的区域。

另请参阅

• geometryEngine.geodesicArea()

示例

// Returns the numeric geodesic area of the given polygon
const area = await geometryEngineAsync.geodesicArea(boundaryPolygon, "square-miles");

geodesicBuffer(geometry, distance, unit, unionResults){Promise<(Polygon|Polygon[])>}

在输入几何周围的指定距离处创建测地线缓冲区面。在计算距离时，此方法会考虑地球的曲率，从而在处理大型几何和/或在全球尺度 (其中一个投影坐标系无法准确绘制坐标并测量所有几何的距离) 上具有空间变化的几何图形时提供高精度结果。

此方法仅适用于 WGS84 (wkid: 4326) 和 Web Mercator 空间参考。通常，如果输入几何被分配了这两个空间参考之一，则应始终使用 geodesicBuffer() 来获得这些几何的最准确结果。如果需要缓冲分配有 的点，请改为使用 buffer()。如果输入几何的地理坐标系不是 WGS84 (wkid: 4326)，请使用 geometryService.buffer()。

参数

geometry Geometry|Geometry[] 缓冲区输入的几何。geometry 和 distance 参数必须指定为两个数组或两个非数组。请勿将一个参数指定为数组，另一个指定为非数组。

distance Number|Number[] 用于缓冲的指定距离。geometry 和 distance 参数必须指定为两个数组或两个非数组。请勿将一个参数指定为数组，另一个指定为非数组。当使用几何数组作为输入时，几何数组的长度不必等于 distance 数组的长度。例如，如果您传递一个包含四个几何的数组：[g1, g2, g3, g4] 和一个距离数组：[d1]，则所有四个几何都将由单个距离值缓冲。如果改为使用包含三个距离的数组：[d1, d2, d3]，g1 将按 d1 缓冲，g2 将按 d2 缓冲，g3 和 g4 将按 d3 缓冲。几何数组的值将与距离数组中的值一一匹配，直到达到距离数组的最终值，在这种情况下，该值将应用于剩余的几何。

unit LinearUnits optional 距离的测量单位。默认为输入几何的单位。

unionResults Boolean optional 默认值： false 确定输出几何是否应合并为单个多边形。

返回

类型	描述
Promise<(Polygon|Polygon[])>	解析后，响应是生成的缓冲区。如果将几何数组用作输入，则结果将为数组。如果将单个几何输入到函数中，则该多边形将是单个面。

另请参阅

• geometryEngine.geodesicBuffer()
• geometryEngine.buffer()

示例

const pointButter = await geometryEngineAsync.geodesicBuffer(point, 1000, "kilometers");

geodesicDensify(geometry, maxSegmentLength, maxSegmentLengthUnit){Promise<Geometry>}

返回输入几何的测地线增密版本。使用此函数沿大圆绘制几何线条。

参数

geometry Polyline|Polygon 要进行增密的折线或多边形。

maxSegmentLength Number 允许的最大分段长度 (如果未提供 maxSegmentLengthUnit，则以米为单位)。这必须是正值。

maxSegmentLengthUnit LinearUnits optional maxSegmentLength 的测量单位。如果未提供，单位将默认为 meters。

返回

类型	描述
Promise<Geometry>	解析为增密的几何。

另请参阅

• geometryEngine.geodesicDensify()

示例

// lineGeom is a line geometry
const densifiedGeom = await geometryEngineAsync.geodesicDensify(lineGeom, 10000);

geodesicLength(geometry, unit){Promise<number>}

计算输入几何的长度。与 planarLength() 不同，geodesicLength() 在执行此计算时会考虑地球的曲率。因此，当使用空间参考为 WGS84 (wkid: 4326) 或 Web Mercator 的输入几何时，最佳实践是使用 geodesicLength() 计算长度。如果输入几何具有 Web 墨卡托以外的投影坐标系，请改用 planarLength()。

此方法仅适用于 WGS84 (wkid: 4326) 和 Web Mercator 空间参考。

参数

geometry Geometry 输入的几何。

unit LinearUnits optional 返回值的测量单位。默认为输入几何的单位。

返回

类型	描述
Promise<number>	解析后，响应是输入几何的长度。

另请参阅

• geometryEngine.geodesicLength()

示例

// Returns the numeric geodesic length of the given line
const length = await geometryEngineAsync.geodesicLength(riverGeometry, "miles");

intersect(geometry1, geometry2){Promise<Geometry>}

从两个几何之间的交点创建新几何。如果输入几何具有不同的维度 (即点 = 0；折线 = 1；多边形 = 2)，则结果的维度将等于输入的最低维度。下表描述了几何类型的各种组合的预期输出。请注意，geometry1 和 geometry2 在此操作中可以互换，并且如果翻转将返回相同的结果。

Geometry1 类型	Geometry2 类型	结果几何类型
Polygon	Polygon	Polygon
Polygon	Polyline	Polyline
Polygon	Point	Point
Polyline	Polyline	Polyline
Polyline	Point	Point
Point	Point	Point

请注意，两条相交的折线不会返回 Point 几何。相反，此函数将返回两个几何之间相等的折线路径。请参阅 intersectLinesToPoints() 以查找两条折线的相交点。

参数

geometry1 Geometry|Geometry[] 输入几何或几何数组。

geometry2 Geometry 要与 geometry1 相交的几何。

返回

类型	描述
Promise<Geometry>	解析后，响应是输入几何的相交点。

另请参阅

• intersectLinesToPoints()

• geometryEngine.intersect()

示例

// Creates a new geometry from the intersection of the two geometries
const intersecting = await geometryEngineAsync.intersect(boundaryPolygon, buffers);

intersectLinesToPoints(line1, line2){Promise<Point[]>}

起始版本：GeoScene Maps SDK for JavaScript 4.25

解析为两条输入折线相交位置处的点数组。对所有其他几何相交操作使用相交。

参数

line1 Polyline 要在相交操作中使用的第一条折线。

line2 Polyline 要在相交操作中使用的第二条折线。

返回

类型	描述
Promise<Point[]>	输入折线的交点。

另请参阅

• intersect

• geometryEngine.intersectLinesToPoints()

示例

// Creates an array of points for the intersections of the input lines
const intersections = await geometryEngineAsync.intersectLinesToPoints(line1, line2);

intersects(geometry1, geometry2){Promise<boolean>}

指示一个几何图形是否与另一几何图形相交。

参数

geometry1 Geometry 测试几何与其他几何的相交关系。

geometry2 Geometry 相交的几何图形。

返回

类型	描述
Promise<boolean>	解析时，如果输入几何彼此相交，则响应为 true。

另请参阅

• geometryEngine.intersects()

示例

// returns true if two given geometries intersect each other
const isIntersecting = await geometryEngineAsync.intersects(boundaryPolygon, cityPolygon);

isSimple(geometry){Promise<boolean>}

指示给定几何在拓扑上是否简单。在简化几何中，不会出现多边形环或折线路径重叠，也不会发生自相交。

参数

geometry Geometry 输入的几何。

返回

类型	描述
Promise<boolean>	解析时，如果几何是简单拓扑的，则响应为 true。

另请参阅

• geometryEngine.isSimple()

示例

// returns true if given geometry is simple
const simple = await geometryEngineAsync.isSimple(polyline);

nearestCoordinate(geometry, inputPoint){Promise<NearestPointResult>}

查找最接近指定点的几何的坐标。

参数

geometry Geometry 要考虑的几何。

inputPoint Point 用于在几何中搜索最近坐标的点。

返回

类型	描述
Promise<NearestPointResult>	解析为 NearestPointResult 的一个实例，其中包含与 inputPoint 最近的坐标。

另请参阅

• geometryEngine.nearestCoordinate()

nearestVertex(geometry, inputPoint){Promise<NearestPointResult>}

在距离指定点最近的几何上查找折点。

参数

geometry Geometry 要考虑的几何。

inputPoint Point 用于在几何中搜索最近折点的点。

返回

类型	描述
Promise<NearestPointResult>	解析为 NearestPointResult 的一个实例，其中包含与 inputPoint 最近的折点。

另请参阅

• geometryEngine.nearestVertex()

示例

// Finds the nearest vertex of the polygon to the input point
const {
 coordinate,
 distance
} = await geometryEngineAsync.nearestVertex(boundaryPolygon, point);

nearestVertices(geometry, inputPoint, searchRadius, maxVertexCountToReturn){Promise<NearestPointResult>}

查找距指定点的给定距离内的所有折点，从最近点到最远点排序，并将它们作为对象数组返回。

参数

geometry Geometry 要考虑的几何。

inputPoint Point 要从中测量的点。

searchRadius Number 从输入点开始搜索的距离，使用视图空间参考的单位。

maxVertexCountToReturn Number 要返回的最大折点数。

返回

类型	描述
Promise<NearestPointResult>	解析为 NearestPointResult 的数组，其中包含与 inputPoint 最近的折点。

另请参阅

• geometryEngine.nearestVertices()

示例

// Returns an array of the nearest vertices
const nearest = await geometryEngineAsync.nearestVertices(boundaryPolygon, point, 500, 2);

offset(geometry, offsetDistance, offsetUnit, joinType, bevelRatio, flattenError){Promise<(Geometry|Geometry[])>}

偏移操作可创建一个几何图形，该几何是距输入折线或面的恒定平面距离。它类似于缓冲，但会产生片面结果。

参数

geometry Geometry|Geometry[] 要偏移的几何。

offsetDistance Number 要从输入几何偏移的平面距离。如果 offsetDistance > 0，则偏移几何构造到定向输入几何的右侧，如果 offsetDistance = 0，则几何中没有变化，否则它将构造到左侧。对于简单多边形，外环的方向是顺时针的，对于内环，它是逆时针的。因此，简单多边形的“右侧”始终是其内部。

offsetUnit LinearUnits optional 偏移距离的测量单位。默认为输入几何的单位。

joinType String optional 联接类型。 可能值："round"|"bevel"|"miter"|"square"

bevelRatio Number optional joinType = 'miter' 时适用；将 bevelRatio 乘以偏移距离，其结果决定了相交在斜交之前可以定位多远的斜接偏移相交。

flattenError Number optional joinType = 'round' 时适用；flattenError 可确定结果段与真实圆弧相比的最大距离。该算法不会为每个圆形连接生成超过大约 180 个折点。

返回

类型	描述
Promise<(Geometry|Geometry[])>	解析后，响应是偏移几何。如果将几何数组用作输入，则结果将为数组。如果将单个几何输入到函数中，则该几何将是单个几何。

另请参阅

• geometryEngine.offset()

示例

// Creates a new geometry offset from the provided geometry
const offset = await geometryEngineAsync.offset(boundaryPolygon, 500, "meters", "round");

overlaps(geometry1, geometry2){Promise<boolean>}

指示一个几何图形是否与另一几何图形重叠。

参数

geometry1 Geometry 测试基础几何与其他几何的 "overlaps” 关系。

geometry2 Geometry 测试比较几何与其他几何的 "overlaps” 关系。

返回

类型	描述
Promise<boolean>	解析时，如果两个几何图形重叠，则响应为 true。

另请参阅

• geometryEngine.overlaps()

示例

// returns true if one geometry overlaps another,
// but is not contained or disjointed
const isOverlapping = await geometryEngineAsync.overlaps(polygon, boundaryPolygon);

planarArea(geometry, unit){Promise<number>}

计算输入几何的面积。与 geodesicArea() 不同，planarArea() 使用投影坐标执行此计算，并且不考虑地球的曲率。当使用空间参考为 WGS84 (wkid: 4326) 或 Web Mercator 的输入几何时，最佳实践是使用 geodesicArea() 计算面积。如果输入几何具有 Web 墨卡托以外的投影坐标系，请改用 planarArea()。

参数

geometry Polygon 输入面。

unit AreaUnits optional 返回值的测量单位。默认为输入几何的单位。

返回

类型	描述
Promise<number>	解析后，响应是输入几何的区域。

另请参阅

• geometryEngine.planarArea()

示例

// Returns the numeric area of the given polygon
const area = await geometryEngineAsync.planarArea(boundaryPolygon, "square-miles");

planarLength(geometry, unit){Promise<number>}

计算输入几何的长度。与 geodesicLength() 不同，planarLength() 使用投影坐标，并且在执行此计算时不考虑地球的曲率。当使用空间参考为 WGS84 (wkid: 4326) 或 Web Mercator 的输入几何时，最佳实践是使用 geodesicLength() 计算长度。如果输入几何具有 Web 墨卡托以外的投影坐标系，请改用 planarLength()。

参数

geometry Geometry 输入的几何。

unit LinearUnits optional 返回值的测量单位。默认为输入几何的单位。

返回

类型	描述
Promise<number>	解析后，响应是输入几何的长度。

另请参阅

• geometryEngine.planarLength()

示例

// Returns the numeric length of the given line
const length = await geometryEngineAsync.planarLength(riverGeometry, "miles");

relate(geometry1, geometry2, relation){Promise<boolean>}

指示给定的 DE-9IM 关系是否适用于两个几何。

参数

geometry1 Geometry 关系的第一个几何。

geometry2 Geometry 关系的第二个几何。

relation String 维度扩展的九交模型 (DE-9IM) 矩阵关系 (编码为字符串)，用于测试两个几何的关系。该字符串包含 DE-9IM 矩阵中表示的每个交叉点的测试结果。每个结果都是字符串的一个字符，可以表示为数字 (返回的最大维度：0,1,2)，布尔值 (T 或 F)，或掩码字符 (用于忽略结果：'*')。例如，以下每个 DE-9IM 字符串代码都可用于测试多边形几何是否完全包含线几何：TTTFFTFFT (Boolean)、'T*****FF*' (忽略不相关的交叉点) 或 '102FF*FF*' (维度形式)。每个返回相同的结果。

返回

类型	描述
Promise<boolean>	解析后，如果输入几何的关系成立，则响应为 true。

另请参阅

• geometryEngine.relate()

示例

// returns true if the polygon geometry completely
// contains the polyline based on the DE-9IM string
const isRelated = await geometryEngineAsync.relate(polygon, polyline, "TTTFFTFFT");

rotate(geometry, angle, rotationOrigin){Promise<Geometry>}

将几何图形逆时针旋转指定的度数。旋转围绕质心或给定的旋转点。

参数

geometry Geometry 要旋转的几何图形。

angle Number 旋转角度，以度为单位。

rotationOrigin Point optional 围绕该点旋转几何。默认为几何的质心。

返回

类型	描述
Promise<Geometry>	解析后，响应是旋转的几何。

另请参阅

• geometryEngine.rotate()

示例

// Returns a geometry rotated by 45 degrees
const geometry = await geometryEngineAsync.rotate(boundaryPolygon, 45);

simplify(geometry){Promise<Geometry>}

对几何执行简化操作，这将更改给定的几何，使其定义在拓扑上符合几何类型。在简化操作结束时，不会出现多边形环或折线路径重叠，也不会发生自相交。

参数

geometry Geometry 要简化的几何图形。

返回

类型	描述
Promise<Geometry>	解析后，响应是简化的几何。

另请参阅

• geometryEngine.simplify()

示例

// Topologically simplifies a geometry
const simplified = await geometryEngineAsync.simplify(polyline);
console.log(geometryEngine.isSimple(simplified)); // true

symmetricDifference(leftGeometry, rightGeometry){Promise<(Geometry|Geometry[])>}

创建两个几何图形的对称差异。对称差异包括在任一集合的部分中，但不同时包括在两个集合中。

参数

leftGeometry Geometry|Geometry[] XOR 操作中的 Geometry 示例之一。

rightGeometry Geometry XOR 操作中的 Geometry 示例之一。

返回

类型	描述
Promise<(Geometry|Geometry[])>	解析后，响应是两个几何的对称差异。

另请参阅

• geometryEngine.symmetricDifference()

示例

// Creates a new geometry based on the
// symmetric difference of the two
const geometry = await geometryEngineAsync.symmetricDifference(boundaryPolygon, buffers);

touches(geometry1, geometry2){Promise<boolean>}

指示一个几何图形是否与另一几何图形接触。

参数

geometry1 Geometry 用于测试与其他几何的 "touches” 关系的几何。

geometry2 Geometry 要接触的几何。

返回

类型	描述
Promise<boolean>	解析后，如果 geometry1 接触 geometry2，则响应为 true。

另请参阅

• geometryEngine.touches()

示例

// returns true if the line vertex touches the edge of the polygon
const isTouching = await geometryEngineAsync.touches(polygon, line);

union(geometries){Promise<Geometry>}

所有输入必须具有相同类型的几何，并且共享一个空间参考。

参数

geometries Geometry[] 要进行联合的几何数组。

返回

类型	描述
Promise<Geometry>	解析后，响应是几何的并集。

另请参阅

• geometryEngine.union()

示例

// pt1 and pt2 are point objects to union together
const response = await geometryEngine.union([pt1, pt2]);

within(innerGeometry, outerGeometry){Promise<boolean>}

指示一个几何是否位于另一几何内。

参数

innerGeometry Geometry 用于测试与其他几何的 "within” 关系的基础几何。

outerGeometry Geometry 用于测试与其他几何的 “contains” 关系的比较几何。

返回

类型	描述
Promise<boolean>	解析后，如果 innerGeometry 位于 outerGeometry 内，则响应为 true。

另请参阅

• geometryEngine.within()

示例

// returns true if a geometry is completely within another
const isWithin = await geometryEngineAsync.within(polygon, boundaryPolygon);

类型定义

SpatialReferenceInfo

extendedSpatialReferenceInfo() 方法的返回对象。

属性

tolerance Number 空间参考的 XY 容差。

unitBaseFactor Number 基础系数。

unitID Number 单位 ID。

unitSquareDerivative Number 平方导数。

unitType Number 单位类型。

另请参阅

• geometryEngineAsync.extendedSpatialReferenceInfo()