'); })();
遥感云计算
GISer
2022-05-24
目录

Geometry

# 简介

几何图形（Geometry）是PIE-Engine中的几何图形对象，包括点、线和面等对象，表示一个几何形体对象。PIE-Engine Studio提供构建Geometry算子及Geometry相关算法，包括但不限于坐标点提取、中心点计算、图形几何运算、空间位置判断及计算、格式转换。

# Geometry

函数 返回值
Geometry(geoJson,proj,geodesic,evenOdd) Geometry
参数 类型 说明
geoJson String|PIEGeometry|PIEFeature|Array 几何形体的GeoJSON对象
proj Projection 坐标系对象，null表示4326
geodesic Boolean 未启用
evenOdd Boolean 未启用

# area

计算几何图形的面积，只对面有效。

函数 返回值
area(self, proj) Number
参数 类型 说明
proj Dictionary 投影方式

# 示例

polygon = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
print(polygon.area(None).getInfo())

# bounds

获得几何图形的四至范围矩形。

函数 返回值
bounds(self, maxError, proj) Geometry
参数 类型 说明
maxError Int 最大误差
proj String 投影方式

# 示例

polygon = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
bounds = polygon.bounds(0,None)
print(bounds.getInfo())

Map = pie.Map()
Map.setCenter(85,45,5)
Map.addLayer(pie.Feature(polygon),{'color': "red"}, "polygon")
Map.addLayer(pie.Feature(bounds),{'color': "blue"}, "bounds")
Map

# buffer

返回几何图形在给定距离生成的缓冲区。

函数 返回值
buffer(self, distance, proj) Geometry
参数 类型 说明
distance Int 缓冲距离
proj Dictionary 投影方式

# 示例

polygon = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
buffer = polygon.buffer(100000, None)

Map = pie.Map()
Map.addLayer(polygon,{'color':'red'},'polygon')
Map.addLayer(buffer,{'color':'yellow'},'buffer')
Map.setCenter(85,45,5)
Map

# centroid

获得几何图形的中心点。

函数 返回值
centroid(self, maxError, proj) Geometry
参数 类型 说明
maxError Int 最大误差
proj String 投影方式

# 示例

polygon = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
centerPoint = polygon.centroid(0, None)
print(centerPoint.getInfo())

# containedIn

判断左边的Geometry是否包含在右边的Geometry中，若包含返回True，不包含返回False。

函数 返回值
containedIn(self, right, proj) Boolean
参数 类型 说明
right Geometry 几何对象
proj Dictionary 投影方式

# 示例

a = pie.Geometry.Polygon([[
    [
        86.80129479936647,
        47.42899226581099
    ],
    [
        82.87305373501061,
        47.53413332597603
    ],
    [
        79.52821480892538,
        44.62131637232005
    ],
    [
        95.12449863869472,
        40.29107652773166
    ],
    [
        96.56355724642901,
        43.390491195479
    ],
    [
        86.80129479936647,
        47.42899226581099
    ]
]], None)
b = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
print(a.containedIn(b, None).getInfo())

# contains

判断左边的Geometry是否包含右边的Geometry，若包含返回True，不包含返回False。

函数 返回值
contains(self, right, proj) Boolean
参数 类型 说明
right Geometry 几何对象
proj Dictionary 投影方式

# 示例

a = pie.Geometry.Polygon([[
    [
        86.80129479936647,
        47.42899226581099
    ],
    [
        82.87305373501061,
        47.53413332597603
    ],
    [
        79.52821480892538,
        44.62131637232005
    ],
    [
        95.12449863869472,
        40.29107652773166
    ],
    [
        96.56355724642901,
        43.390491195479
    ],
    [
        86.80129479936647,
        47.42899226581099
    ]
]], None)
b = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
print(a.contains(b, None).getInfo())

# coordinates

返回包含几何图形所有折点坐标的数组。

函数 返回值
coordinates(self) Array

# 示例

polygon = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
coords = polygon.coordinates()
print(coords)

# difference

计算左边的Geometry和右边的Geometry差集。

函数 返回值
difference(self, right, proj) Geometry
参数 类型 说明
right Geometry 几何对象
proj Dictionary 投影方式

# 示例

a = pie.Geometry.Polygon([[
    [
        86.80129479936647,
        47.42899226581099
    ],
    [
        82.87305373501061,
        47.53413332597603
    ],
    [
        79.52821480892538,
        44.62131637232005
    ],
    [
        95.12449863869472,
        40.29107652773166
    ],
    [
        96.56355724642901,
        43.390491195479
    ],
    [
        86.80129479936647,
        47.42899226581099
    ]
]], None)
b = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
c = a.difference(b, None)
print(c.getInfo())

Map = pie.Map()
Map.addLayer(a,{'color':'red'},'a')
Map.addLayer(b,{'color':'blue'},'b')
Map.addLayer(c,{'color':'yellow'},'c')
Map.setCenter(85,45,5)
Map

# disjoint

判断左边的Geometry是否和右边的Geometry相离，若相离返回True，不相离返回False。

函数 返回值
disjoint(self, right, proj) Boolean
参数 类型 说明
right Geometry 几何对象
proj Dictionary 投影方式

# 示例

a = pie.Geometry.Polygon([[
    [
        86.80129479936647,
        47.42899226581099
    ],
    [
        82.87305373501061,
        47.53413332597603
    ],
    [
        79.52821480892538,
        44.62131637232005
    ],
    [
        95.12449863869472,
        40.29107652773166
    ],
    [
        96.56355724642901,
        43.390491195479
    ],
    [
        86.80129479936647,
        47.42899226581099
    ]
]], None)
b = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
print(a.disjoint(b, None).getInfo())

# getGeometryCoordinates

获取Geometry数据的坐标列表。

函数 返回值
getGeometryCoordinates(self) JSON

# 示例

polygon = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
print(polygon.getGeometryCoordinates())

# getGeometryType

获取矢量数据的类型。

函数 返回值
getGeometryType(self) Value

# 示例

featureCollection = pie.FeatureCollection("user/101/public/shape/Shi_HeBei")
print(featureCollection.first().geometry().getGeometryType())

# intersection

计算左边的Geometry和右边的Geometry交集。

函数 返回值
intersection(self, right, proj) Geometry
参数 类型 说明
right Geometry 几何对象
proj Dictionary 投影方式

# 示例

a = pie.Geometry.Polygon([[
    [
        86.80129479936647,
        47.42899226581099
    ],
    [
        82.87305373501061,
        47.53413332597603
    ],
    [
        79.52821480892538,
        44.62131637232005
    ],
    [
        95.12449863869472,
        40.29107652773166
    ],
    [
        96.56355724642901,
        43.390491195479
    ],
    [
        86.80129479936647,
        47.42899226581099
    ]
]], None)
b = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
c = a.intersection(b, None)
print(c.getInfo())

Map = pie.Map()
Map.addLayer(a,{'color':'red'},'a')
Map.addLayer(b,{'color':'blue'},'b')
Map.addLayer(c,{'color':'yellow'},'c')
Map.setCenter(85,45,5)
Map

# intersects

判断左边的Geometry是否和右边的Geometry相交，若相交返回True，不相交返回False。

函数 返回值
intersects(self, right, proj) Boolean
参数 类型 说明
right Geometry 几何对象
proj Dictionary 投影方式

# 示例

a = pie.Geometry.Polygon([[
    [
        86.80129479936647,
        47.42899226581099
    ],
    [
        82.87305373501061,
        47.53413332597603
    ],
    [
        79.52821480892538,
        44.62131637232005
    ],
    [
        95.12449863869472,
        40.29107652773166
    ],
    [
        96.56355724642901,
        43.390491195479
    ],
    [
        86.80129479936647,
        47.42899226581099
    ]
]], None)
b = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
print(a.intersects(b, None).getInfo())

# length

计算几何图形的长度或周长，只对线面有效。

函数 返回值
length(self, proj) Number
参数 类型 说明
proj Dictionary 投影方式

# 示例

line = pie.Geometry.LineString([
    [
        86.21755088013333,
        42.173683155554215
    ],
    [
        95.75003820467464,
        45.90600966211181
    ]
],None)
print(line.length(None).getInfo())

# LinearRing

构造线圈对象。

函数 返回值
LinearRing(coords, proj, geodesic=True, maxError=None) Geometry
参数 类型 说明
coords List 坐标列表
proj String 投影方式
geodesic Boolean 默认为True
maxError Int 默认为None

# 示例

lineRing = pie.Geometry.LinearRing([
    [
        116.70308106546304,
        31.653299950850567
    ],
    [
        116.7525195420265,
        31.49183820635301
    ],
    [
        117.05464356546463,
        31.57845391213783
    ],
    [
        116.99696534280838,
        31.73042184813434
    ],
    [
        116.70308106546304,
        31.653299950850567
    ]], None)
print(lineRing.getInfo())

# LineString

构造线对象。

函数 返回值
LineString(coords, proj, geodesic=True, maxError=None) Geometry
参数 类型 说明
coords List 坐标列表
proj String 投影方式
geodesic Boolean 默认为True
maxError Int 默认为None

# 示例

m = pie.Map()
polyline = pie.Geometry.LineString([[118, 31.1], [119, 31.1], [119, 32.1]], None)
roi = pie.FeatureCollection(pie.Feature(polyline))
m.addLayer(roi, {'color': "white"}, "roi")
m.setCenter(119,31,7)
m

# MultiLineString

构造复合线对象。

函数 返回值
MultiLineString(coords, proj, geodesic=True, maxError=None) Geometry
参数 类型 说明
coords List 坐标列表
proj String 投影方式
geodesic Boolean 默认为True
maxError Int 默认为None

# 示例

m = pie.Map()
mulPolyline = pie.Geometry.MultiLineString([[[118, 31.1], [119, 31.1], [119, 32.1]],[[118.5, 31.6],[120, 35],[130, 40]]], None)
roi = pie.FeatureCollection(pie.Feature(mulPolyline))
m.addLayer(roi, {'color': "white"}, "roi")
m.setCenter(119,32,7)
m

# MultiPoint

构造复合点对象。

函数 返回值
MultiPoint(coords, proj) Geometry
参数 类型 说明
coords List 坐标列表
proj String 投影方式

# 示例

multipoint = pie.Geometry.MultiPoint([
    [
        114.299587241509641,
        30.588191458230682
    ],
    [
        114.571659944120995,
        30.486732447659577
    ],
    [
        114.027801565074299,
        30.527317283313749]
], None)

# MultiPolygon

构造复合多边形对象。

函数 返回值
MultiPolygon(coords, proj, geodesic=True, maxError=None, evenOdd=True) Geometry
参数 类型 说明
coords List 坐标列表
proj String 投影方式
geodesic Boolean 默认为True
maxError Int 默认为None
evenOdd Boolean 默认为True

# 示例

multipolygon = pie.Geometry.MultiPolygon([
    [[
        [115.94056054688679,40.00634562357601],
        [116.28113671875832,40.00634562357601],
        [116.28113671875832,39.81041118621047],
        [115.94056054688679,39.81041118621047],
        [115.94056054688679,40.00634562357601]
    ]],
    [[
        [116.53382226563411,39.983199809357046],
        [116.8304531250078,39.983199809357046],
        [116.8304531250078,39.78508851352569],
        [116.53382226563411,39.78508851352569],
        [116.53382226563411,39.983199809357046]
    ]]
], None)

Map = pie.Map()
Map.setCenter(116.5,39.9,9)
Map.addLayer(pie.Feature(multipolygon),{'color': "red"}, "multipolygon")
Map

# perimeter

计算面的周长。

函数 返回值
perimeter(proj) Number
参数 类型 说明
proj Dictionary 投影方式

# 示例

geometry = pie.Geometry.Polygon([[
        [
            120.02328711376367,
            41.417783485315425
        ],
        [
            120.2979453168931,
            41.40130397339212
        ],
        [
            120.25400000438702,
            41.2197535295559
        ],
        [
            120.02328711376367,
            41.417783485315425
        ]
    ]], None)
print(geometry.perimeter(None).getInfo())

# Point

构造点对象。

函数 返回值
Point(coords, proj) Geometry
参数 类型 说明
coords List 坐标列表
proj String 投影方式

# 示例

point = pie.Geometry.Point([118.5, 31.6] , None)

# Polygon

构造多边形对象。

函数 返回值
Polygon(coords, proj, geodesic=True, maxError=None, evenOdd=True) Geometry
参数 类型 说明
coords List 坐标列表
proj String 投影方式
geodesic Boolean 默认为True
maxError Int 默认为None
evenOdd Boolean 默认为True

# 示例

polygon = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)

Map = pie.Map()
Map.setCenter(82,45,5)
Map.addLayer(pie.Feature(polygon),{'color': "red"}, "polygon")
Map

# Rectangle

构造矩形对象。

函数 返回值
Rectangle(coords, proj, geodesic=True, evenOdd=True) Geometry
参数 类型 说明
coords List 坐标列表或矩形两个角点的坐标点序列的集合
proj String 投影方式
geodesic Boolean 默认为True
evenOdd Boolean 默认为True

# 示例1：

rectangle = pie.Geometry.Rectangle([[118, 31.1], [119, 32.1]], None)
Map = pie.Map()
Map.setCenter(118.5,31.6,8)
Map.addLayer(pie.Feature(rectangle),{'color': "red"}, "rectangle")
Map

# 示例2：

m = pie.Map()
rectangle = pie.Geometry.Rectangle(
    [[116.38036624714744, 32.066195797640304], 
     [116.36114017293437, 31.795802008253787],
    [116.62481204792908, 31.779459721570262],
    [116.38036624714744, 32.066195797640304]], None)
print(rectangle.getInfo())
m.addLayer(rectangle,{'color':'red'},'rectangle')
m.setCenter(116.4,31.8,9)
m

# simplify

对几何图形对象进行简化。

函数 返回值
simplify(self, proj) Geometry
参数 类型 说明
proj Dictionary 投影方式

# 示例

featureCollection = pie.FeatureCollection("NGCC/CHINA_PROVINCE_BOUNDARY")
f0 = featureCollection.getAt(0).geometry()
print(f0.simplify(None).getInfo())

# toGeoJSON

返回表示几何图形对象GeoJSON对象。

函数 返回值
toGeoJSON() JSON

# 示例

line = pie.Geometry.LineString([
    [
        86.21755088013333,
        42.173683155554215
    ],
    [
        95.75003820467464,
        45.90600966211181
    ]
], None)
print(line.toGeoJSON())

# toGeoJSONString

返回表示几何图形对象的GeoJSON字符串。

函数 返回值
toGeoJSONString() String

# 示例

line = pie.Geometry.LineString([
    [
        86.21755088013333,
        42.173683155554215
    ],
    [
        95.75003820467464,
        45.90600966211181
    ]
], None)
print(line.toGeoJSONString())

# union

计算左边的Geometry和右边的Geometry并集。

函数 返回值
union(self, right, proj) Geometry
参数 类型 说明
right Geometry 几何对象
proj Dictionary 投影方式

# 示例

a = pie.Geometry.Polygon([[
    [
        86.80129479936647,
        47.42899226581099
    ],
    [
        82.87305373501061,
        47.53413332597603
    ],
    [
        79.52821480892538,
        44.62131637232005
    ],
    [
        95.12449863869472,
        40.29107652773166
    ],
    [
        96.56355724642901,
        43.390491195479
    ],
    [
        86.80129479936647,
        47.42899226581099
    ]
]], None)
b = pie.Geometry.Polygon([[
    [
        76.0641376209303,
        44.11876326018208
    ],
    [
        80.83964695953506,
        49.800143138994855
    ],
    [
        89.95652842415888,
        48.14753031988744
    ],
    [
        82.74985069498081,
        41.50791700751361
    ],
    [
        76.0641376209303,
        44.11876326018208
    ]
]], None)
c = a.union(b, None)
print(c.getInfo())

Map = pie.Map()
Map.addLayer(a,{'color':'red'},'a')
Map.addLayer(b,{'color':'blue'},'b')
Map.addLayer(c,{'color':'yellow'},'c')
Map.setCenter(85,45,5)
Map

# withinDistance

判断左边的Geometry与右边Geometry的相隔距离是否在给定范围内，若是返回True，不是返回False。

函数 返回值
withinDistance(self, right, distance, proj) Boolean
参数 类型 说明
right Geometry 几何对象
proj Dictionary 投影方式
distance Int 缓冲距离

# 示例

featureCollection = pie.FeatureCollection("NGCC/CHINA_PROVINCE_BOUNDARY")
f0 = featureCollection.getAt(0).geometry()
f1 = featureCollection.getAt(1).geometry()
print(f0.withinDistance(f1, 1000000, None).getInfo())
有问题，我来改改 (opens new window)
上次更新: 2022/05/25, 07:37:39
Filter
Image

← Image→

最近更新
01
太湖水体浑浊度计算
05-25
02
太湖水域蓝藻密度分析
05-25
03
北京城市建设用地情况分析
05-25
更多文章>
Theme by Vdoing | Copyright © 2021-2022 蜀ICP备2021024989号-3