Shapely用户手册¶

作者: 肖恩·吉利斯，<sean.gillies@gmail.com>
版本: 1.7.0
日期: 2022 年 10 月 04 日
版权: 这项工作是根据 `Creative Commons Attribution 3.0 United States License`_ _.

摘要: 本文档介绍如何将shapely python包用于计算几何图形。

介绍¶

确定性空间分析是解决农业、生态学、流行病学、社会学和许多其他领域问题的计算方法的重要组成部分。这些动物栖息地的调查周长/面积比是多少？这个镇上的哪些财产与这个新洪水模型中50年一遇的洪水等值线相交？有“A”和“B”标记的古代陶瓷器的范围是多少？范围在哪里重叠？从家到办公室的最佳途径是什么？找出基于位置的垃圾邮件区域？这些只是一些可以通过非统计空间分析解决的问题，更具体地说，是计算几何。

shapely是一个python包，用于设置平面特征的理论分析和操作（通过python的 ctypes 模块）来自著名和广泛部署的地理类库的功能。GEOS，一个 Java Topology Suite （JTS）是PostgreSQL RDBMS的PostGIS空间扩展的几何引擎。联合特遣部队和全球测地系统的设计主要受 Open Geospatial Consortium 的简单功能访问规范 1 并大致依附于同一套标准类和操作。因此，shapely深深植根于地理信息系统（gis）世界的惯例，但也希望对处理非常规问题的程序员同样有用。

shapely的第一个前提是，Python程序员应该能够在RDBMS之外执行PostGIS类型的几何操作。并非所有地理数据都源自或驻留在RDBMS中，或者最好使用SQL进行处理。我们可以将数据加载到一个空间RDBMS中来完成工作，但是如果没有管理（RDBMS中的“m”）数据库中的数据的授权，那么我们就使用了错误的工具来完成工作。第二个前提是特征的持久性、序列化和映射投影是重要的，但是是正交的问题。你可能不需要一百个地理信息系统格式的读者和作者，也不需要大量的州平面投影，而且形状也不会给你带来负担。第三个前提是Python熟语TrAMP GIS（或Java，在这种情况下，因为GEOS库来自JTS，Java项目）的成语。

如果您喜欢并从惯用的python中获益，那么请欣赏能够很好地完成一件事情的软件包，并同意支持空间的RDBMS通常足以作为计算几何任务的错误工具，而shapely可能适合您。

空间数据模型¶

由shapely实现的几何对象的基本类型是点、曲线和曲面。每个点都与平面中的三组（可能是无限的）点相关联。这个 interior, boundary, 和 exterior 特征集是互斥的，它们的并集与整个平面重合。 2 .

A Point 有一个 interior 刚好一点的集合，A boundary 完全没有点的集合，以及 exterior 所有其他点的集合。一 Point 拓扑维数为0。
A Curve 有一个 interior 由沿其长度的无穷多点组成的集合（假设 Point 拖进太空），a boundary 由两个端点组成的集合，以及 exterior 所有其他点的集合。一 Curve 拓扑维数为1。
A Surface 有一个 interior 包含无限多个点的集合（假设 Curve 在空间中拖动以覆盖一个区域），a boundary 由一个或多个组成的集合 Curves, 和一个 exterior 所有其他点的集合，包括可能存在于表面的孔内的点。一 Surface 拓扑维数为2。

这可能看起来有点深奥，但有助于澄清shapely的空间谓词的含义，而且它和本手册一样深入到理论中。点集理论的结果，包括一些表现为“gotchas”的理论，将在本手册后面讨论。

点类型由 Point 类；曲线 LineString 和 LinearRing 等级；表面 Polygon 班级。shapely实现没有平滑（即“有连续切线”）曲线。所有曲线必须用线性样条曲线来近似。所有的圆面片必须近似于由线性样条线包围的区域。

点集合由 MultiPoint 类，曲线集合 MultiLineString 类和曲面集合 MultiPolygon 班级。这些集合在计算上并不重要，但对于建模某些类型的特性很有用。例如，Y形线条特征可通过 MultiLineString.

标准数据模型具有特定于特定几何对象类型的附加约束，这些约束将在本手册的以下章节中讨论。

另请参阅https://web.archive.org/web/20160719195511/http://www.vividsolutions.com/jts/discussion.htm了解此数据模型的更多说明。

关系¶

空间数据模型伴随着一组几何对象之间的自然语言关系- contains ， intersects ， overlaps ， touches 以及一个理论框架，用它们的组成点集的相互交集的3x3矩阵来理解它们 3: 德-9IM。有关DE-9IM的关系的全面回顾见 4 本手册将不再重复。

操作¶

遵循JTS技术规范 5 ，本手册将对构造（buffer， convex hull) 并设置理论运算（intersection， union, 等等）。个人操作将在本手册的以下章节中详细描述。

坐标系¶

即使地球不是平坦的，也不完全是球形的，但仍有许多分析问题可以通过将地球特征转换为笛卡尔平面，应用经过验证的算法，然后将结果转换回地理坐标来解决。这种做法与精确纸质地图的传统一样古老。

shapely不支持坐标系转换。对两个或多个特征的所有操作都假定这些特征存在于同一笛卡尔平面中。

几何对象¶

几何对象是以典型的Python方式创建的，使用类本身作为实例工厂。它们的一些内在属性将在本节中讨论，其他属性将在下面的操作和序列化部分中讨论。

实例 Point ， LineString 和 LinearRing 有一个有限的坐标序列作为它们最重要的属性，它决定了它们的内部、边界和外部点集。一个字符串可以由2个点来确定，但包含无限多个点。坐标序列是不可变的。A第三 z 坐标值可以在构造实例时使用，但对几何分析没有影响。所有操作都在 x-y 飞机。

在所有构造函数中，数值转换为类型 float . 换言之， Point(0, 0) 和 Point(0.0, 0.0) 生成几何等效实例。shapely在构造实例时不会检查实例的拓扑简单性或有效性，因为在大多数情况下，成本是没有根据的。使用 :attr:``is_valid` `由需要谓词的用户进行谓词。

备注

shapely是一个平面几何库， z, 几何分析中忽略了平面上或平面下的高度。这里的用户有一个潜在的陷阱：只在 z 它们之间没有区别，它们的应用可能导致极其无效的几何对象。例如， LineString([(0, 0, 0), (0, 0, 1)]) 不返回单位长度的垂直线，而是返回长度为零的平面中的无效线。同样地， Polygon([(0, 0, 0), (0, 0, 1), (1, 1, 1)]) 不受闭合环的约束，因此无效。

一般属性和方法¶

object.area¶: 返回区域（ float ）对象的。

object.bounds¶: 返回A (minx, miny, maxx, maxy) 元组（元组） float 值）限制对象的值。

object.length¶: 返回长度（ float ）对象的。

object.minimum_clearance¶

返回可以移动节点以生成无效几何体的最小距离。

这可以被认为是一个几何体鲁棒性的度量，其中最小间隙值越大，表示几何体越坚固。如果几何图形（例如点）不存在最小间隙，则将返回该值 math.infinity .

New in Shapely 1.7.1

需要GEOS 3.6或更高版本。

>>> from shapely.geometry import Polygon
>>> Polygon([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]).minimum_clearance
1.0

object.geom_type¶: 返回一个指定 Geometry Type 根据 1 .

>>> Point(0, 0).geom_type
'Point'

object.distance(other)¶: 返回最小距离（ float ） other 几何对象。

>>> Point(0,0).distance(Point(1,1))
1.4142135623730951

object.hausdorff_distance(other)¶

返回Hausdorff距离 (float ） other 几何对象。两个几何体之间的hausdorff距离是两个几何体上的一个点从最近的点到另一个几何体上的点的最远距离。

New in Shapely 1.6.0

>>> point = Point(1, 1)
>>> line = LineString([(2, 0), (2, 4), (3, 4)])
>>> point.hausdorff_distance(line)
3.605551275463989
>>> point.distance(Point(3, 4))
3.605551275463989

object.representative_point()¶: 返回一个保证位于几何对象内的廉价计算点。

备注

这通常与质心不同。

>>> donut = Point(0, 0).buffer(2.0).difference(Point(0, 0).buffer(1.0))
>>> donut.centroid.wkt
'POINT (-0.0000000000000001 -0.0000000000000000)'
>>> donut.representative_point().wkt
'POINT (-1.5000000000000000 0.0000000000000000)'

点¶

class Point(coordinates)¶: 这个 Point 构造函数接受位置坐标值或点元组参数。

>>> from shapely.geometry import Point
>>> point = Point(0.0, 0.0)
>>> q = Point((0.0, 0.0))

A Point 面积为零，长度为零。

>>> point.area
0.0
>>> point.length
0.0

它的 x-y 边界框是一个 (minx, miny, maxx, maxy) 元组。

>>> point.bounds
(0.0, 0.0, 0.0, 0.0)

坐标值通过 coords, x, y, 和 z 性质。

>>> list(point.coords)
[(0.0, 0.0)]
>>> point.x
0.0
>>> point.y
0.0

坐标也可以切片。 New in version 1.2.14.

>>> point.coords[:]
[(0.0, 0.0)]

这个 Point 构造函数也接受另一个 Point 实例，从而复制。

>>> Point(point)
<shapely.geometry.point.Point object at 0x...>

LineStrings¶

class LineString(coordinates)¶: 这个 LineString 构造函数接受2个或更多的有序序列 (x, y[, z]) 点元组。

构造的 LineString 对象表示点之间的一个或多个连接的线性样条线。允许按顺序重复点，但可能会招致性能惩罚，应避免。一 LineString 可能会交叉（*I.E.*Be complex 而不是 simple) .

（ Source code ， png ， hires.png ， pdf ）

图1。简单的 LineString 在左边，一个复杂的 LineString 在右边。每个点的（multipoint）边界显示为黑色，描述线条的其他点显示为灰色。

A LineString 具有零面积和非零长度。

>>> from shapely.geometry import LineString
>>> line = LineString([(0, 0), (1, 1)])
>>> line.area
0.0
>>> line.length
1.4142135623730951

它的 x-y 边界框是一个 (minx, miny, maxx, maxy) 元组。

>>> line.bounds
(0.0, 0.0, 1.0, 1.0)

定义的坐标值通过 coords 财产。

>>> len(line.coords)
2
>>> list(line.coords)
[(0.0, 0.0), (1.0, 1.0)]

坐标也可以切片。 New in version 1.2.14.

>>> point.coords[:]
[(0.0, 0.0), (1.0, 1.0)]
>>> point.coords[1:]
[(1.0, 1.0)]

构造函数还接受另一个 LineString 实例，从而复制。

>>> LineString(line)
<shapely.geometry.linestring.LineString object at 0x...>

A LineString 也可以使用混合序列 Point 实例或坐标元组。将单个坐标复制到新对象中。

>>> LineString([Point(0.0, 1.0), (2.0, 3.0), Point(4.0, 5.0)])
<shapely.geometry.linestring.LineString object at 0x...>

LinearRings¶

class LinearRing(coordinates)¶: 这个 LinearRing 构造函数接受 (x, y[, z]) 点元组。

序列可以通过在第一个和最后一个索引中传递相同的值来显式关闭。否则，将第一个元组复制到最后一个索引，从而隐式关闭序列。和A一样 LineString, 允许按顺序重复点，但可能会招致性能惩罚，应避免。A LinearRing 不可横穿自身，也不可单点接触自身。

（ Source code ， png ， hires.png ， pdf ）

图2。有效的 LinearRing 在左边，一个无效的自我触摸 LinearRing 在右边。描述环的点以灰色显示。环的边界是 empty.

备注

形状不会阻止此类环的创建，但在操作时会引发异常。

A LinearRing 具有零面积和非零长度。

>>> from shapely.geometry.polygon import LinearRing
>>> ring = LinearRing([(0, 0), (1, 1), (1, 0)])
>>> ring.area
0.0
>>> ring.length
3.4142135623730949

它的 x-y 边界框是一个 (minx, miny, maxx, maxy) 元组。

>>> ring.bounds
(0.0, 0.0, 1.0, 1.0)

定义坐标值可通过 coords 财产。

>>> len(ring.coords)
4
>>> list(ring.coords)
[(0.0, 0.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0)]

这个 LinearRing 构造函数也接受另一个 LineString 或 LinearRing 实例，从而复制。

>>> LinearRing(ring)
<shapely.geometry.polygon.LinearRing object at 0x...>

和一样 LineString, 一系列 Point 实例不是有效的构造函数参数。

多边形¶

class Polygon(shell[, holes=None])¶: 这个 Polygon 构造函数接受两个位置参数。第一个是有序的 (x, y[, z]) 点元组和的处理方式与 LinearRing 案例。第二个是一个可选的无序的环状序列序列，用于指定特征的内部边界或“孔”。

A的环 valid `多边形不能相互交叉，但只能在一个点上接触。同样，shapely不会阻止创建无效的功能，但在操作时会引发异常。

（ Source code ， png ， hires.png ， pdf ）

图3.在左边，一个有效的 Polygon 带有一个内环，在一个点与外环接触，在右侧A Polygon 那就是 invalid 因为它的内环与外环的接触不止一个点。描述环的点以灰色显示。

（ Source code ， png ， hires.png ， pdf ）

图4。在左边，一个 Polygon 那就是 invalid 因为它的外环和内环沿着一条线接触，而在右边， Polygon 那就是 invalid 因为它的内环是沿着一条线接触的。

A Polygon 具有非零区域和非零长度。

>>> from shapely.geometry import Polygon
>>> polygon = Polygon([(0, 0), (1, 1), (1, 0)])
>>> polygon.area
0.5
>>> polygon.length
3.4142135623730949

它的 x-y 边界框是一个 (minx, miny, maxx, maxy) 元组。

>>> polygon.bounds
(0.0, 0.0, 1.0, 1.0)

组件环通过 exterior 和 interiors 性质。

>>> list(polygon.exterior.coords)
[(0.0, 0.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0)]
>>> list(polygon.interiors)
[]

这个 Polygon 构造函数还接受的实例 LineString 和 LinearRing.

>>> coords = [(0, 0), (1, 1), (1, 0)]
>>> r = LinearRing(coords)
>>> s = Polygon(r)
>>> s.area
0.5
>>> t = Polygon(s.buffer(1.0).exterior, [r])
>>> t.area
6.5507620529190334

矩形多边形通常出现，并且可以使用 shapely.geometry.box() 功能。

shapely.geometry.box(minx, miny, maxx, maxy, ccw=True)¶

根据提供的边界框值生成矩形多边形，默认为逆时针顺序。

New in version 1.2.9.

例如：

>>> from shapely.geometry import box
>>> b = box(0.0, 0.0, 1.0, 1.0)
>>> b
<shapely.geometry.polygon.Polygon object at 0x...>
>>> list(b.exterior.coords)
[(1.0, 0.0), (1.0, 1.0), (0.0, 1.0), (0.0, 0.0), (1.0, 0.0)]

这是第一次出现形状明确的多边形手习惯。

要获得具有已知方向的多边形，请使用 shapely.geometry.polygon.orient() ：

shapely.geometry.polygon.orient(polygon, sign=1.0)¶

返回给定多边形的正确定向副本。结果的有符号区域将具有给定的符号。符号1.0表示产品外环坐标为逆时针方向，内环（孔）为顺时针方向。

New in version 1.2.10.

收藏¶

几何对象的异类集合可能是由某些形状操作造成的。例如，两个 LineStrings 可以沿直线和点相交。为了表示这些结果，shapely提供了几何对象的frozenset类不可变集合。集合可以是同构的（“多点”等）或异构的。

>>> a = LineString([(0, 0), (1, 1), (1,2), (2,2)])
>>> b = LineString([(0, 0), (1, 1), (2,1), (2,2)])
>>> x = a.intersection(b)
>>> x
<shapely.geometry.collection.GeometryCollection object at 0x...>
>>> from pprint import pprint
>>> pprint(list(x))
[<shapely.geometry.point.Point object at 0x...>,
 <shapely.geometry.linestring.LineString object at 0x...>]

（ Source code ， png ， hires.png ， pdf ）

图5。a）一条绿色线和一条黄色线，沿着一条线和一个点相交；b）交叉点（蓝色）是一个集合，其中包含一个 LineString 一个 Point.

A成员 GeometryCollection 通过访问 geoms 属性或通过迭代器协议使用 in 或 list() .

>>> pprint(list(x.geoms))
[<shapely.geometry.point.Point object at 0x...>,
 <shapely.geometry.linestring.LineString object at 0x...>]
>>> pprint(list(x))
[<shapely.geometry.point.Point object at 0x...>,
 <shapely.geometry.linestring.LineString object at 0x...>]

还可以对集合进行切片。

>>> from shapely.geometry import MultiPoint
>>> m = MultiPoint([(0, 0), (1, 1), (1,2), (2,2)])
>>> m[:1].wkt
'MULTIPOINT (0.0000000000000000 0.0000000000000000)'
>>> m[3:].wkt
'MULTIPOINT (2.0000000000000000 2.0000000000000000)'
>>> m[4:].wkt
'GEOMETRYCOLLECTION EMPTY'

New in version 1.2.14.

备注

如果可能，最好使用下面描述的同构收集类型之一。

积分集合¶

class MultiPoint(points)¶: 这个 MultiPoint 构造函数接受一个序列 (x, y[, z ]) 点元组。

A MultiPoint 面积为零，长度为零。

>>> from shapely.geometry import MultiPoint
>>> points = MultiPoint([(0.0, 0.0), (1.0, 1.0)])
>>> points.area
0.0
>>> points.length
0.0

它的 x-y 边界框是一个 (minx, miny, maxx, maxy) 元组。

>>> points.bounds
(0.0, 0.0, 1.0, 1.0)

多点集合的成员通过 geoms 属性或通过迭代器协议使用 in 或 list() .

>>> import pprint
>>> pprint.pprint(list(points.geoms))
[<shapely.geometry.point.Point object at 0x...>,
 <shapely.geometry.point.Point object at 0x...>]
>>> pprint.pprint(list(points))
[<shapely.geometry.point.Point object at 0x...>,
 <shapely.geometry.point.Point object at 0x...>]

构造函数还接受另一个 MultiPoint 实例或无序序列 Point 实例，从而复制。

>>> MultiPoint([Point(0, 0), Point(1, 1)])
<shapely.geometry.multipoint.MultiPoint object at 0x...>

行集合¶

class MultiLineString(lines)¶: 这个 MultiLineString 构造器接受一个类似行的序列或对象序列。

（ Source code ， png ， hires.png ， pdf ）

图6。在左边，一个 simple, 断开的 MultiLineString, 在右边，一个不简单的 MultiLineString. 定义对象的点以灰色显示，对象的边界以黑色显示。

A MultiLineString 具有零面积和非零长度。

>>> from shapely.geometry import MultiLineString
>>> coords = [((0, 0), (1, 1)), ((-1, 0), (1, 0))]
>>> lines = MultiLineString(coords)
>>> lines.area
0.0
>>> lines.length
3.4142135623730949

它的 x-y 边界框是一个 (minx, miny, maxx, maxy) 元组。

>>> lines.bounds
(-1.0, 0.0, 1.0, 1.0)

它的成员是 LineString 并通过 geoms 属性或通过迭代器协议使用 in 或 list() .

>>> len(lines.geoms)
2
>>> pprint.pprint(list(lines.geoms))
[<shapely.geometry.linestring.LineString object at 0x...>,
 <shapely.geometry.linestring.LineString object at 0x...>]
>>> pprint.pprint(list(lines))
[<shapely.geometry.linestring.LineString object at 0x...>,
 <shapely.geometry.linestring.LineString object at 0x...>]

构造函数还接受的另一个实例 MultiLineString 或者一个无序的序列 LineString 实例，从而复制。

>>> MultiLineString(lines)
<shapely.geometry.multilinestring.MultiLineString object at 0x...>
>>> MultiLineString(lines.geoms)
<shapely.geometry.multilinestring.MultiLineString object at 0x...>

多边形集合¶

class MultiPolygon(polygons)¶: 这个 MultiPolygon 构造器获取外部环和孔列表元组的序列：[（a1，…，am），[（b1，…，bn），…]，…]。

更清楚地说，构造函数还接受一个无序的 Polygon 实例，从而复制。

>>> polygons = MultiPolygon([polygon, s, t])
>>> len(polygons.geoms)
3

（ Source code ， png ， hires.png ， pdf ）

图7.在左边，A valid 多多边形，有两个成员，在右边是 `MultiPolygon 这是无效的，因为它的成员接触无限多的点（沿着一条线）。

它的 x-y 边界框是一个 (minx, miny, maxx, maxy) 元组。

>>> polygons.bounds
(-1.0, -1.0, 2.0, 2.0)

它的成员是 Polygon 并通过 geoms 财产。

>>> len(polygons.geoms)
3

空功能¶

“空”特征是指点集与空集重合的特征；不是 None ，但像 set([]) . 可以通过调用不带参数的各种构造函数来创建空特性。空特性几乎不支持任何操作。

>>> line = LineString()
>>> line.is_empty
True
>>> line.length
0.0
>>> line.bounds
()
>>> line.coords
[]

可以设置空特征的坐标，之后几何图形不再为空。

>>> line.coords = [(0, 0), (1, 1)]
>>> line.is_empty
False
>>> line.length
1.4142135623730951
>>> line.bounds
(0.0, 0.0, 1.0, 1.0)

坐标序列¶

描述几何图形的坐标列表表示为 CoordinateSequence 对象。这些序列不应直接初始化，但可以从现有几何图形访问 Geometry.coords 财产。

>>> line = LineString([(0, 1), (2, 3), (4, 5)])
>>> line.coords
<shapely.coords.CoordinateSequence object at 0x00000276EED1C7F0>

坐标序列可以被索引、切片和迭代，就好像它们是坐标元组列表一样。

>>> line.coords[0]
(0.0, 1.0)
>>> line.coords[1:]
[(2.0, 3.0), (4.0, 5.0)]
>>> for x, y in line.coords:
...     print("x={}, y={}".format(x, y))
...
x=0.0, y=1.0
x=2.0, y=3.0
x=4.0, y=5.0

多边形的外部和每个内部环都有一个坐标序列。

>>> poly = Polygon([(0, 0), (0, 1), (1, 1), (0, 0)])
>>> poly.exterior.coords
<shapely.coords.CoordinateSequence object at 0x00000276EED1C048>

多部分几何图形没有坐标序列。相反，坐标序列存储在其组件几何上。

>>> p = MultiPoint([(0, 0), (1, 1), (2, 2)])
>>> p[2].coords
<shapely.coords.CoordinateSequence object at 0x00000276EFB9B320>

线性参考方法¶

沿着线性特征指定位置可能很有用，例如 LineStrings 和 MultiLineStrings 具有一维参考系统。形状支持基于长度或距离的线性引用，计算沿几何对象到给定点投影的距离，或沿对象的给定距离处的点。

object.interpolate(distance[, normalized=False])¶: 沿线性几何对象返回指定距离处的点。

如果 normalized arg是 True ，距离将被解释为几何对象长度的一部分。

>>> ip = LineString([(0, 0), (0, 1), (1, 1)]).interpolate(1.5)
>>> ip
<shapely.geometry.point.Point object at 0x740570>
>>> ip.wkt
'POINT (0.5000000000000000 1.0000000000000000)'
>>> LineString([(0, 0), (0, 1), (1, 1)]).interpolate(0.75, normalized=True).wkt
'POINT (0.5000000000000000 1.0000000000000000)'

object.project(other[, normalized=False])¶: 返回沿此几何对象到最近点的距离 other 对象。

如果 normalized arg是 True ，返回标准化为对象长度的距离。这个 project() 方法与 interpolate() .

>>> LineString([(0, 0), (0, 1), (1, 1)]).project(ip)
1.5
>>> LineString([(0, 0), (0, 1), (1, 1)]).project(ip, normalized=True)
0.75

例如，可以使用线性参照方法在指定的距离处切割直线。

def cut(line, distance):
    # Cuts a line in two at a distance from its starting point
    if distance <= 0.0 or distance >= line.length:
        return [LineString(line)]
    coords = list(line.coords)
    for i, p in enumerate(coords):
        pd = line.project(Point(p))
        if pd == distance:
            return [
                LineString(coords[:i+1]),
                LineString(coords[i:])]
        if pd > distance:
            cp = line.interpolate(distance)
            return [
                LineString(coords[:i] + [(cp.x, cp.y)]),
                LineString([(cp.x, cp.y)] + coords[i:])]

>>> line = LineString([(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0)])
>>> pprint([list(x.coords) for x in cut(line, 1.0)])
[[(0.0, 0.0), (1.0, 0.0)],
 [(1.0, 0.0), (2.0, 0.0), (3.0, 0.0), (4.0, 0.0), (5.0, 0.0)]]
>>> pprint([list(x.coords) for x in cut(line, 2.5)])
[[(0.0, 0.0), (1.0, 0.0), (2.0, 0.0), (2.5, 0.0)],
 [(2.5, 0.0), (3.0, 0.0), (4.0, 0.0), (5.0, 0.0)]]

谓词和关系¶

中解释的类型的对象几何对象提供标准 1 谓词作为属性（用于一元谓词）和方法（用于二元谓词）。无论是一元还是二元，都返回 True 或 False .

一元谓词¶

标准的一元谓词实现为只读属性属性。每个都将显示一个示例。

object.has_z¶: 返回 True 如果功能不仅 x 和 y, 而且 z 三维（或所谓的2.5d）几何图形的坐标。

>>> Point(0, 0).has_z
False
>>> Point(0, 0, 0).has_z
True

object.is_ccw¶

返回 True 如果坐标为逆时针顺序（用正符号区域包围区域）。此方法适用于 LinearRing 只有对象。

New in version 1.2.10.

>>> LinearRing([(1,0), (1,1), (0,0)]).is_ccw
True

具有不需要的方向的环可以这样反转：

>>> ring = LinearRing([(0,0), (1,1), (1,0)])
>>> ring.is_ccw
False
>>> ring.coords = list(ring.coords)[::-1]
>>> ring.is_ccw
True

object.is_empty¶: 返回 True 如果功能 interior 和 boundary （用点集术语）与空集一致。

>>> Point().is_empty
True
>>> Point(0, 0).is_empty
False

备注

在…的帮助下 operator 模块的 attrgetter() 函数，一元谓词，如 is_empty 可轻松用作内置的谓词 filter() 或 itertools.ifilter() .

>>> from operator import attrgetter
>>> empties = filter(attrgetter('is_empty'), [Point(), Point(0, 0)])
>>> len(empties)
1

object.is_ring¶: 返回 True 如果特征是封闭的和简单的 LineString . 一个封闭的特征 boundary 与空集重合。

>>> LineString([(0, 0), (1, 1), (1, -1)]).is_ring
False
>>> LinearRing([(0, 0), (1, 1), (1, -1)]).is_ring
True

此属性适用于 LineString 和 LinearRing 实例，但对其他人来说毫无意义。

object.is_simple¶: 返回 True 如果特性本身没有交叉。

备注

简单性测试只对 LineStrings 和 LinearRings.

>>> LineString([(0, 0), (1, 1), (1, -1), (0, 1)]).is_simple
False

非简单操作 LineStrings 完全由形状支持。

object.is_valid¶: 返回 True 如果某个功能在以下意义上是“有效的” 1 .

备注

有效性测试仅对 Polygons 和 MultiPolygons . True 对于其他类型的几何图形，始终返回。

有效的 Polygon 不能有任何重叠的内外环。有效的 MultiPolygon 不能收集任何重叠的多边形。对无效功能的操作可能失败。

>>> MultiPolygon([Point(0, 0).buffer(2.0), Point(1, 1).buffer(2.0)]).is_valid
False

上面的两个点非常接近，以至于缓冲区操作（在下面一节中解释）产生的多边形重叠。

备注

这个 is_valid 谓词可用于编写一个验证修饰符，该修饰符可确保从构造函数函数仅返回有效的对象。

from functools import wraps
def validate(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        ob = func(*args, **kwargs)
        if not ob.is_valid:
            raise TopologicalError(
                "Given arguments do not determine a valid geometric object")
        return ob
    return wrapper

>>> @validate
... def ring(coordinates):
...     return LinearRing(coordinates)
...
>>> coords = [(0, 0), (1, 1), (1, -1), (0, 1)]
>>> ring(coords)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 7, in wrapper
shapely.geos.TopologicalError: Given arguments do not determine a valid geometric object

二元谓词¶

标准的二进制谓词作为方法实现。这些谓词评估拓扑关系、集合理论关系。在一些情况下，结果可能不是人们从不同的假设开始所期望的。都以另一个几何对象为参数并返回 True 或 False .

object.__eq__(other)¶: 返回 True 如果两个对象的几何类型相同，并且两个对象的坐标精确匹配。

object.equals(other)¶: 返回 True 如果集合理论上 boundary, interior, 和 exterior 物体与另一物体的重合。

传递给对象构造函数的坐标是这些集合的坐标，并确定它们，但不是集合的整体。对于新用户来说，这是一个潜在的“抓住机会”。例如，等值线可以用不同的方式构造。

>>> a = LineString([(0, 0), (1, 1)])
>>> b = LineString([(0, 0), (0.5, 0.5), (1, 1)])
>>> c = LineString([(0, 0), (0, 0), (1, 1)])
>>> a.equals(b)
True
>>> a == b
False
>>> b.equals(c)
True
>>> b == c
False

object.almost_equals(other[, decimal=6])¶: 返回 True 如果对象近似等于 other 在指定的所有点 decimal 放置精度。

object.contains(other)¶: 返回 True 如果没有点 other 位于 object 和至少一个点的内部 other 位于 object.

此谓词适用于所有类型，与 within() . 表达式 a.contains(b) == b.within(a) 始终计算为 True .

>>> coords = [(0, 0), (1, 1)]
>>> LineString(coords).contains(Point(0.5, 0.5))
True
>>> Point(0.5, 0.5).within(LineString(coords))
True

线的端点是其 boundary 因此不包含。

>>> LineString(coords).contains(Point(1.0, 1.0))
False

备注

二元谓词可直接用作 filter() 或 itertools.ifilter() .

>>> line = LineString(coords)
>>> contained = filter(line.contains, [Point(), Point(0.5, 0.5)])
>>> len(contained)
1
>>> [p.wkt for p in contained]
['POINT (0.5000000000000000 0.5000000000000000)']

object.covers(other)¶: 退货 True 如果每一点 other 是位于的内部或边界上的点 object 。这类似于 object.contains(other) 但这不需要任何内点 other 躺在…的内部 object 。

object.covered_by(other)¶

退货 True 如果每一点 object 是位于的内部或边界上的点 other 。这相当于 other.covers(object) 。

New in version 1.8 。

object.crosses(other)¶: 返回 True 如果 interior 对象与 interior 另一个的，但不包含它，并且交集的尺寸小于一个或另一个的尺寸。

>>> LineString(coords).crosses(LineString([(0, 1), (1, 0)]))
True

一条线不会穿过它所包含的点。

>>> LineString(coords).crosses(Point(0.5, 0.5))
False

object.disjoint(other)¶: 返回 True 如果 boundary 和 interior 物体与另一物体完全不相交。

>>> Point(0, 0).disjoint(Point(1, 1))
True

这个谓词适用于所有类型，是 intersects() .

object.intersects(other)¶: 返回 True 如果 boundary 或 interior 物体以任何方式与另一物体相交。

换句话说，如果几何对象有任何共同的边界或内部点，它们就会相交。

object.overlaps(other)¶: 返回 True 如果几何图形有多个共同点，但不是所有点，则具有相同的尺寸，并且几何图形内部的交点具有与几何图形本身相同的尺寸。

object.touches(other)¶: 返回 True 如果物体至少有一个共同点，并且其内部不与另一个物体的任何部分相交。

因此，重叠的特征不会 touch, 另一个潜在的“抓住机会”。例如，下面几行触摸 (1, 1) ，但不要重叠。

>>> a = LineString([(0, 0), (1, 1)])
>>> b = LineString([(1, 1), (2, 2)])
>>> a.touches(b)
True

object.within(other)¶: 返回 True 如果对象是 boundary 和 interior 只与…相交 interior 另一个（不是 boundary 或 exterior) .

这适用于所有类型，与 contains() .

用于 sorted() key, within() 便于对对象进行空间排序。假设我们有4个立体的特征：一个点由另一个多边形所包含的多边形所包含，一个自由精神的点由无多边形所包含。

>>> a = Point(2, 2)
>>> b = Polygon([[1, 1], [1, 3], [3, 3], [3, 1]])
>>> c = Polygon([[0, 0], [0, 4], [4, 4], [4, 0]])
>>> d = Point(-1, -1)

并且这些副本被收集到一个列表中

>>> features = [c, a, d, b, c]

我们想订的是 [d, c, c, b, a] 以相反的遏制顺序。如python中所述 Sorting HowTo, we can define a key function that operates on each list element and returns a value for comparison. Our key function will be a wrapper class that implements __lt__() using Shapely's binary within() 谓语。

class Within:
    def __init__(self, o):
        self.o = o
    def __lt__(self, other):
        return self.o.within(other.o)

正如Howto所说， less than 在排序时，保证使用比较。这就是我们在空间排序上所依赖的，也是我们使用的原因 within() 相反而不是 contains() . 在功能上尝试 d 和 c, 我们看到它起作用了。

>>> d < c
True
>>> Within(d) < Within(c)
False

它也适用于特性列表，生成我们想要的订单。

>>> [d, c, c, b, a] == sorted(features, key=Within, reverse=True)
True

DE-9IM关系¶

这个 relate() 方法测试所有DE-9IM 4 对象之间的关系，上面的命名关系谓词是其中的一个子集。

object.relate(other)¶: 返回对象之间关系的de-9im矩阵的字符串表示形式 interior, boundary, exterior 以及另一个几何物体的。

命名关系谓词（ contains() 等）通常作为包装纸 relate() .

主要有两个不同点 F （假）矩阵中的值；它们的交集 external 集合（第9个元素）是 2 标注对象（平面的其余部分）。交叉点 interior 一个与 exterior 另一个是 0 维度对象（矩阵的第3和第7个元素）。

>>> Point(0, 0).relate(Point(1, 1))
'FF0FFF0F2'

一条直线和一条直线上的点的矩阵有更多的“真”（不是 F ）元素。

>>> Point(0, 0).relate(LineString([(0, 0), (1, 1)]))
'F0FFFF102'

object.relate_pattern(other, pattern)¶: 如果几何图形之间的关系的de-9im字符串代码满足模式，则返回true，否则返回false。

这个 relate_pattern() 将两个几何图形的de-9im代码字符串与指定的模式进行比较。如果字符串与模式匹配，则 True 被退回，否则 False . 指定的模式可以完全匹配（ 0 ， 1 或 2 ）布尔匹配（ T 或 F ）或通配符（ * ）例如，用于 within 谓语是 T*****FF* .

>> point = Point(0.5, 0.5)
>> square = Polygon([(0, 0), (0, 1), (1, 1), (1, 0)])
>> square.relate_pattern(point, 'T*****FF*')
True
>> point.within(square)
True

请注意，顺序或几何图形非常重要，如下所示。在本例中，正方形包含点，但点不包含正方形。

>>> point.relate(square)
'0FFFFF212'
>>> square.relate(point)
'0F2FF1FF2'

有关DE-9IM矩阵的进一步讨论超出了本手册的范围。见 4 和https://pypi.org/project/de9im/。

空间分析方法¶

除了布尔属性和方法之外，shapely还提供返回新几何对象的分析方法。

集合论方法¶

几乎每个二元谓词方法都有一个对应的方法，它返回一个新的几何对象。另外，集合论 boundary 对象的属性是只读的。

备注

这些方法会 always 返回几何对象。例如，不相交的几何图形的交集将返回空的 GeometryCollection, 不 None 或 False. 要测试非空结果，请使用几何图形的 is_empty 财产。

object.boundary¶: 返回表示对象集理论值的低维对象 boundary.

多边形的边界是线，线的边界是点的集合。点的边界是空（空）集合。

>> coords = [((0, 0), (1, 1)), ((-1, 0), (1, 0))]
>>> lines = MultiLineString(coords)
>>> lines.boundary
<shapely.geometry.multipoint.MultiPoint object at 0x...>
>>> pprint(list(lines.boundary))
[<shapely.geometry.point.Point object at 0x...>,
 <shapely.geometry.point.Point object at 0x...>,
 <shapely.geometry.point.Point object at 0x...>,
 <shapely.geometry.point.Point object at 0x...>]
>>> lines.boundary.boundary
<shapely.geometry.collection.GeometryCollection object at 0x...>
>>> lines.boundary.boundary.is_empty
True

请参阅中的数字 LineStrings 和行集合用于绘制线条及其边界。

object.centroid¶: 返回对象几何形心（点）的表示形式。

>>> LineString([(0, 0), (1, 1)]).centroid
<shapely.geometry.point.Point object at 0x...>
>>> LineString([(0, 0), (1, 1)]).centroid.wkt
'POINT (0.5000000000000000 0.5000000000000000)'

备注

一个物体的质心可能是它的一个点，但这并不能保证。

object.difference(other)¶: 返回组成此几何对象的点的表示形式，这些点不构成 other 对象。

>>> a = Point(1, 1).buffer(1.5)
>>> b = Point(2, 1).buffer(1.5)
>>> a.difference(b)
<shapely.geometry.polygon.Polygon object at 0x...>

备注

这个 buffer() 该方法用于在本节的示例中生成近似圆形的多边形；本手册后面将详细解释该方法。

（ Source code ， png ， hires.png ， pdf ）

图8。两个近似圆形多边形之间的差异。

备注

shapely不能将对象和低维对象之间的差异（例如多边形和直线或点之间的差异）表示为单个对象，在这种情况下，difference方法返回名为 self .

object.intersection(other)¶: 返回此对象与 other 几何对象。

>>> a = Point(1, 1).buffer(1.5)
>>> b = Point(2, 1).buffer(1.5)
>>> a.intersection(b)
<shapely.geometry.polygon.Polygon object at 0x...>

见下图 symmetric_difference() 下面。

object.symmetric_difference(other)¶: 返回此对象中不在 other 几何对象，以及 other 不在这个几何物体中。

>>> a = Point(1, 1).buffer(1.5)
>>> b = Point(2, 1).buffer(1.5)
>>> a.symmetric_difference(b)
<shapely.geometry.multipolygon.MultiPolygon object at ...>

（ Source code ， png ， hires.png ， pdf ）

object.union(other)¶: 返回此对象和 other 几何对象。

返回的对象类型取决于操作数之间的关系。多边形的联合（例如）将是一个多边形或多个多边形，这取决于它们是否相交。

>>> a = Point(1, 1).buffer(1.5)
>>> b = Point(2, 1).buffer(1.5)
>>> a.union(b)
<shapely.geometry.polygon.Polygon object at 0x...>

这些操作的语义因几何对象的类型而异。例如，将多边形并集的边界与其边界的并集进行比较。

>>> a.union(b).boundary
<shapely.geometry.polygon.LinearRing object at 0x...>
>>> a.boundary.union(b.boundary)
<shapely.geometry.multilinestring.MultiLineString object at 0x...>

（ Source code ， png ， hires.png ， pdf ）

备注

union() 是查找多个对象累积联合的昂贵方法。见 shapely.ops.unary_union() 更有效的方法。

可以使用重载运算符调用这些集合论方法中的一些：

intersection can be accessed with and, &
union can be accessed with or, |
difference can be accessed with minus, -
symmetric_difference can be accessed with xor, ^

>>> from shapely import wkt
>>> p1 = wkt.loads('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))')
>>> p2 = wkt.loads('POLYGON((0.5 0, 1.5 0, 1.5 1, 0.5 1, 0.5 0))')
>>> (p1 & p2).wkt
'POLYGON ((1 0, 0.5 0, 0.5 1, 1 1, 1 0))'
>>> (p1 | p2).wkt
'POLYGON ((0.5 0, 0 0, 0 1, 0.5 1, 1 1, 1.5 1, 1.5 0, 1 0, 0.5 0))'
>>> (p1 - p2).wkt
'POLYGON ((0.5 0, 0 0, 0 1, 0.5 1, 0.5 0))'
>>> (p1 ^ p2).wkt
'MULTIPOLYGON (((0.5 0, 0 0, 0 1, 0.5 1, 0.5 0)), ((1 0, 1 1, 1.5 1, 1.5 0, 1 0)))'

建设性方法¶

形状几何对象有几种方法可以产生新的对象，而不是从集合理论分析中推导出来的。

object.buffer(distance, resolution=16, cap_style=1, join_style=1, mitre_limit=5.0, single_sided=False)¶

返回给定中所有点的近似表示形式 distance 这个几何物体的。

大写的样式由整数值指定：1（圆）、2（平）、3（平方）。这些值也由对象枚举 shapely.geometry.CAP_STYLE （见下文）。

偏移段之间的连接样式由整数值指定：1（圆形）、2（斜接）和3（斜接）。这些值也由对象枚举 shapely.geometry.JOIN_STYLE （见下文）。

shapely.geometry.CAP_STYLE¶

属性	价值
圆	1
平的	2
广场	3

shapely.geometry.JOIN_STYLE¶

属性	价值
圆	1
斜接	2
斜角	3

>>> from shapely.geometry import CAP_STYLE, JOIN_STYLE
>>> CAP_STYLE.flat
2
>>> JOIN_STYLE.bevel
3

正距离有膨胀的作用；负距离有侵蚀作用。可选的 resolution 参数确定用于近似点周围四分之一圆的分段数。

>>> line = LineString([(0, 0), (1, 1), (0, 2), (2, 2), (3, 1), (1, 0)])
>>> dilated = line.buffer(0.5)
>>> eroded = dilated.buffer(-0.3)

（ Source code ， png ， hires.png ， pdf ）

图9。线（左）的扩张和多边形（右）的侵蚀。新对象显示为蓝色。

一个点的默认（`resolution`为16）缓冲区是一个多边形补丁，其面积约为圆形磁盘面积的99.8%。

>>> p = Point(0, 0).buffer(10.0)
>>> len(p.exterior.coords)
66
>>> p.area
313.65484905459385

用一个 resolution 缓冲区是一个正方形的补丁。

>>> q = Point(0, 0).buffer(10.0, 1)
>>> len(q.exterior.coords)
5
>>> q.area
200.0

您可能只需要一侧的缓冲区。您可以使用以下工具来实现此效果 single_sided 选择。

使用的一侧由缓冲距离的符号确定：

正距离表示左侧
距离为负值表示右侧

>>> line = LineString([(0, 0), (1, 1), (0, 2), (2, 2), (3, 1), (1, 0)])
>>> left_hand_side = line.buffer(0.5, single_sided=True)
>>> right_hand_side = line.buffer(-0.3, single_sided=True)

(Source code _, png ， hires.png ， pdf )

图10.左手0.5和右手0.3的单面缓冲区

点几何图形的单面缓冲区与常规缓冲区相同。单面缓冲区的End Cap样式始终被忽略，并强制为等效于 CAP_STYLE.flat 。

通过 distance 0， buffer() 有时可用于“清洁”自接触或自交叉多边形，如经典的“领结”。用户报告说，非常小的距离值有时会产生比0更清晰的结果。清洁表面时，里程数可能会有所不同。

>>> coords = [(0, 0), (0, 2), (1, 1), (2, 2), (2, 0), (1, 1), (0, 0)]
>>> bowtie = Polygon(coords)
>>> bowtie.is_valid
False
>>> clean = bowtie.buffer(0)
>>> clean.is_valid
True
>>> clean
<shapely.geometry.multipolygon.MultiPolygon object at ...>
>>> len(clean.geoms)
2
>>> list(clean.geoms[0].exterior.coords)
[(0.0, 0.0), (0.0, 2.0), (1.0, 1.0), (0.0, 0.0)]
>>> list(clean.geoms[1].exterior.coords)
[(1.0, 1.0), (2.0, 2.0), (2.0, 0.0), (1.0, 1.0)]

缓冲在多边形接触点将多边形分成两部分。

object.convex_hull¶: 返回最小凸的表示形式 Polygon 包含对象中的所有点，除非对象中的点少于三个。对于两个点，凸面Shell塌陷为 LineString; 对于1，A Point.

>>> Point(0, 0).convex_hull
<shapely.geometry.point.Point object at 0x...>
>>> MultiPoint([(0, 0), (1, 1)]).convex_hull
<shapely.geometry.linestring.LineString object at 0x...>
>>> MultiPoint([(0, 0), (1, 1), (1, -1)]).convex_hull
<shapely.geometry.polygon.Polygon object at 0x...>

（ Source code ， png ， hires.png ， pdf ）

图11.凸壳(蓝色)为2点(左)和6点(右)。

object.envelope¶: 返回包含对象的点或最小矩形多边形（边与坐标轴平行）的表示形式。

>>> Point(0, 0).envelope
<shapely.geometry.point.Point object at 0x...>
>>> MultiPoint([(0, 0), (1, 1)]).envelope
<shapely.geometry.polygon.Polygon object at 0x...>

object.minimum_rotated_rectangle¶

返回包含该对象的常规最小边框。与包络不同，此矩形不受约束与坐标轴平行。如果对象的凸面Shell是退化（线或点），则返回该退化。

New in Shapely 1.6.0

>>> Point(0, 0).minimum_rotated_rectangle
<shapely.geometry.point.Point object at 0x...>
>>> MultiPoint([(0,0),(1,1),(2,0.5)]).minimum_rotated_rectangle
<shapely.geometry.polygon.Polygon object at 0x...>

（ Source code ， png ， hires.png ， pdf ）

图12.多点要素(左)和线串要素(右)的最小旋转矩形

object.parallel_offset(distance, side, resolution=16, join_style=1, mitre_limit=5.0)¶

返回与对象右侧或左侧相距一定距离的LineString或MultiLineString几何图形。

这个 distance 参数必须是正浮点值。

这个 side 参数可以是“left”或“right”。左和右是由线串的给定几何点的方向确定的。右侧偏移以原始线串或线环的相反方向返回，而左侧偏移沿相同方向流动。

这个 resolution 对象每个顶点周围偏移量的 buffer() 方法。

这个 join_style 用于线段之间的外角。可接受的整数值为1（圆形）、2（斜接）和3（斜面）。另请参见 shapely.geometry.JOIN_STYLE .

严重斜接的角落可以通过 mitre_limit 参数（用英国英语拼写，en-gb）。平行线的角点将比使用斜接连接样式的大多数位置离原始位置更远。此距离与指定距离的比率 distance 是斜接比。比率超过限制的拐角将被斜切。

备注

此方法有时可能返回 MultiLineString 一个简单的 LineString 应为；例如，对稍微弯曲的字符串的偏移量。

备注

此方法仅适用于 LinearRing 和 LineString 物体。

（ Source code ， png ， hires.png ， pdf ）

图13.简单线串(其起点显示为圆)左侧的三种平行偏移线样式和右侧的一种偏移量，即多部分。

影响 mitre_limit 参数如下所示。

（ Source code ， png ， hires.png ， pdf ）

图14.左偏移量和右偏移量的大和小mitre_Limit值

object.simplify(tolerance, preserve_topology=True)¶: 返回几何对象的简化表示形式。

简化对象中的所有点都将位于 tolerance 原始几何图形的距离。默认情况下，使用较慢的算法来保留拓扑。如果“保留拓扑”设置为 False 更快的道格拉斯-派克算法 6 使用。

>>> p = Point(0.0, 0.0)
>>> x = p.buffer(1.0)
>>> x.area
3.1365484905459389
>>> len(x.exterior.coords)
66
>>> s = x.simplify(0.05, preserve_topology=False)
>>> s.area
3.0614674589207187
>>> len(s.exterior.coords)
17

（ Source code ， png ， hires.png ， pdf ）

图15.使用0.2(左)和0.5(右)的公差简化近似圆形的多边形。

备注

Invalid 几何对象可能是由于不保留拓扑的简化而产生的，简化可能对坐标顺序敏感：两个仅在坐标顺序上不同的几何可能会被不同地简化。

仿射转换¶

仿射变换函数的集合位于 shapely.affinity 模块，通过直接向仿射变换矩阵提供系数或使用特定的命名变换（rotate），返回变换的几何图形。 scale, 等等）。这些函数可用于所有几何图形类型（除了 GeometryCollection) 三维仿射变换可以保留或支持三维类型。

New in version 1.2.17.

shapely.affinity.affine_transform(geom, matrix)¶

返回使用仿射变换矩阵转换的几何体。

系数 matrix 以列表或元组的形式提供，其中分别有6项或12项用于二维或三维转换。

对于二维仿射变换，6个参数 matrix 是：

[a, b, d, e, xoff, yoff]

表示增广矩阵：

\[\开始{bmatrix}\]

或转换坐标的方程式：

\[\begin{split}x'&=a x+b y+x\mathrm{off}\\\end{split}\]

对于三维仿射变换，12参数 matrix 是：

[a, b, c, d, e, f, g, h, i, xoff, yoff, zoff]

表示增广矩阵：

\[\开始{bmatrix}\]

或转换坐标的方程式：

\[\begin{split}x'&=a x+b y+c z+x\mathrm{off}\\\end{split}\]

shapely.affinity.rotate(geom, angle, origin='center', use_radians=False)¶

返回二维平面上的旋转几何图形。

旋转角度可以通过设置指定为度（默认）或弧度。 use_radians=True . 正的角度是逆时针的，负的是顺时针的旋转。

原点可以是关键字 'center' 对于边界框中心（默认）， 'centroid' 对于几何体的质心，a Point 对象或坐标元组 (x0, y0) .

二维带角旋转的仿射变换矩阵 \(\theta\) 是：

\[\开始{bmatrix}\]

从原点计算偏移量的位置 \((x_0, y_0)\) ：

\[\begin{split}x{mathrm{off}&=xu0-xu0\cos{\theta}+yu0\sin{\theta}\\\end{split}\]

>>> from shapely import affinity
>>> line = LineString([(1, 3), (1, 1), (4, 1)])
>>> rotated_a = affinity.rotate(line, 90)
>>> rotated_b = affinity.rotate(line, 90, origin='centroid')

（ Source code ， png ， hires.png ， pdf ）

图16.旋转 LineString (灰色)使用不同的原点逆时针(蓝色)成90°角。

shapely.affinity.scale(geom, xfact=1.0, yfact=1.0, zfact=1.0, origin='center')¶

返回按比例缩放的几何图形，并按每个维度上的因子进行缩放。

原点可以是关键字 'center' 对于二维边界框中心（默认值）， 'centroid' 对于几何体的二维质心，a Point 对象或坐标元组 (x0, y0, z0) .

负比例因子将镜像或反射坐标。

用于缩放的一般3D仿射变换矩阵为：

\[\开始{bmatrix}\]

从原点计算偏移量的位置 \((x_0, y_0, z_0)\) ：

\[\begin{split}x\mathrm{off}&=x_0-xu0 x{fact}\\\end{split}\]

>>> triangle = Polygon([(1, 1), (2, 3), (3, 1)])
>>> triangle_a = affinity.scale(triangle, xfact=1.5, yfact=-1)
>>> triangle_a.exterior.coords[:]
[(0.5, 3.0), (2.0, 1.0), (3.5, 3.0), (0.5, 3.0)]
>>> triangle_b = affinity.scale(triangle, xfact=2, origin=(1,1))
>>> triangle_b.exterior.coords[:]
[(1.0, 1.0), (3.0, 3.0), (5.0, 1.0), (1.0, 1.0)]

（ Source code ， png ， hires.png ， pdf ）

图17.将灰色三角形缩放到蓝色的结果是：a)沿x方向增加1.5倍，沿y轴反射；b)沿x方向增加2倍，自定义原点位于(1，1)。

shapely.affinity.skew(geom, xs=0.0, ys=0.0, origin='center', use_radians=False)¶

返回一个倾斜的几何体，该几何体沿X和Y维度被角度剪切。

可以通过设置以度（默认）或弧度指定剪切角。 use_radians=True .

原点可以是关键字 'center' 对于边界框中心（默认）， 'centroid' 对于几何体的质心，a Point 对象或坐标元组 (x0, y0) .

用于倾斜的一般二维仿射变换矩阵为：

\[\开始{bmatrix}\]

从原点计算偏移量的位置 \((x_0, y_0)\) ：

\[\begin{split}x\mathrm{off}&=-y_0\tan{x}\\\end{split}\]

（ Source code ， png ， hires.png ， pdf ）

图18.灰色“R”向蓝色倾斜的结果是：a)沿x方向的剪切角度为20°，原点为(1，1)；b)使用默认原点，沿y方向的剪切角度为30°。

shapely.affinity.translate(geom, xoff=0.0, yoff=0.0, zoff=0.0)¶

返回沿每个维度偏移的已转换几何图形。

一般用于翻译的三维仿射变换矩阵为：

\[\开始{bmatrix}\]

其他转换¶

形状支持地图投影和几何对象的其他任意转换。

shapely.ops.transform(func, geom)¶

应用 func 到的所有坐标 geom 并从转换后的坐标中返回相同类型的新几何图形。

func 将x、y和z（可选）映射到输出xp、yp、zp。输入参数可以是iterable类型，如列表或数组或单个值。输出应为同一类型：标量输入，标量输出；列表输入，列表输出。

transform 尝试通过调用来确定传入了哪种类型的函数 func 首先用n个坐标系，其中n是输入几何体的维数。如果 func 提高 TypeError 当以iterables作为参数调用时，它将改为调用 func 在几何体中的每个单独坐标上。

New in version 1.2.18.

例如，这里有一个标识函数适用于两种类型的输入（标量或数组）。

def id_func(x, y, z=None):
    return tuple(filter(None, [x, y, z]))

g2 = transform(id_func, g1)

如果使用 pyproj>=2.1.0 ，投影几何图形的首选方法是：

import pyproj

from shapely.geometry import Point
from shapely.ops import transform

wgs84_pt = Point(-72.2495, 43.886)

wgs84 = pyproj.CRS('EPSG:4326')
utm = pyproj.CRS('EPSG:32618')

project = pyproj.Transformer.from_crs(wgs84, utm, always_xy=True).transform
utm_point = transform(project, wgs84_pt)

需要注意的是，在上面的示例中 always_xy 由于Shapely仅支持X、Y顺序的坐标，因此需要kwarg，在项目6中，WGS84 CRS使用EPSG定义的纬度/经度坐标顺序，而不是预期的Lon/Lat。

如果使用 pyproj < 2.1 ，那么典型的例子是：

from functools import partial
import pyproj

from shapely.ops import transform

wgs84 = pyproj.Proj(init='epsg:4326')
utm = pyproj.Proj(init='epsg:32618')

project = partial(
    pyproj.transform,
    wgs84,
    utm)

utm_point = transform(project, wgs84_pt)

lambda表达式，例如

g2 = transform(lambda x, y, z=None: (x+1.0, y+1.0), g1)

同时满足以下要求： func.

其他业务¶

合并线性特征¶

触摸线的序列可以合并到 MultiLineStrings 或 Polygons 在中使用函数 shapely.ops 模块。

shapely.ops.polygonize(lines)¶

返回从输入构造的多边形上的迭代器 lines.

如同 MultiLineString 构造函数，输入元素可以是任何类似行的对象。

>>> from shapely.ops import polygonize
>>> lines = [
...     ((0, 0), (1, 1)),
...     ((0, 0), (0, 1)),
...     ((0, 1), (1, 1)),
...     ((1, 1), (1, 0)),
...     ((1, 0), (0, 0))
...     ]
>>> pprint(list(polygonize(lines)))
[<shapely.geometry.polygon.Polygon object at 0x...>,
 <shapely.geometry.polygon.Polygon object at 0x...>]

shapely.ops.polygonize_full(lines)¶

从线条源创建多边形，返回多边形和剩余几何图形。

源可以是多行字符串、一系列LineString对象或一系列不适合LineString的对象。

返回对象的元组：（多边形、悬垂、剪切边、无效的环形线）。每个都是一个几何集合。

悬垂是指一端或两端不与另一个边缘端点相连的边缘。切割边在两端连接，但不构成多边形的一部分。无效的环线形成无效的环（蝴蝶结等）。

New in version 1.2.18.

>>> lines = [
...     ((0, 0), (1, 1)),
...     ((0, 0), (0, 1)),
...     ((0, 1), (1, 1)),
...     ((1, 1), (1, 0)),
...     ((1, 0), (0, 0)),
...     ((5, 5), (6, 6)),
...     ((1, 1), (100, 100)),
...     ]
>>> result, dangles, cuts, invalids = polygonize_full(lines)
>>> len(result.geoms)
2
>>> list(result.geoms)
[<shapely.geometry.polygon.Polygon object at ...>, <shapely.geometry.polygon.Polygon object at ...>]
>>> list(cuts.geoms)
[<shapely.geometry.linestring.LineString object at ...>, <shapely.geometry.linestring.LineString object at ...>]

shapely.ops.linemerge(lines)¶

返回A LineString 或 MultiLineString 表示所有相邻元素的合并 lines.

和一样 shapely.ops.polygonize() ，输入元素可以是任何类似行的对象。

>>> from shapely.ops import linemerge
>>> linemerge(lines)
<shapely.geometry.multilinestring.MultiLineString object at 0x...>
>>> pprint(list(linemerge(lines)))
[<shapely.geometry.linestring.LineString object at 0x...>,
 <shapely.geometry.linestring.LineString object at 0x...>,
 <shapely.geometry.linestring.LineString object at 0x...>]

高效的矩形裁剪¶

这个 clip_by_rect() 中的函数 shapely.ops 返回几何图形在矩形内的部分。

shapely.ops.clip_by_rect(geom, xmin, ymin, xmax, ymax)¶

几何体以一种快速但可能肮脏的方式进行剪裁。不能保证输出是有效的。对于拓扑错误不会引发任何异常。

New in version 1.7.

需要GEOS 3.5.0或更高版本

>>> from shapely.geometry import Polygon
>>> from shapely.ops import clip_by_rect
>>> polygon = Polygon(
       shell=[(0, 0), (0, 30), (30, 30), (30, 0), (0, 0)],
       holes=[[(10, 10), (20, 10), (20, 20), (10, 20), (10, 10)]],
    )
>>> clipped_polygon = clip_by_rect(polygon, 5, 5, 15, 15)
>>> print(clipped_polygon.wkt)
POLYGON ((5 5, 5 15, 10 15, 10 10, 15 10, 15 5, 5 5))

高效工会¶

这个 unary_union() 中的函数 shapely.ops 比积累更有效 union() .

(Source code _, png ， hires.png ， pdf ）

shapely.ops.unary_union(geoms)¶

返回给定几何对象的并集的表示形式。

重叠区域 Polygons 将被合并。 LineStrings 会完全溶解并点头。复制 Points 将被合并。

>>> from shapely.ops import unary_union
>>> polygons = [Point(i, 0).buffer(0.7) for i in range(5)]
>>> unary_union(polygons)
<shapely.geometry.polygon.Polygon object at 0x...>

因为工会合并了重叠的区域 Polygons 它可以用来修复无效的 MultiPolygons .和零距离一样 buffer() 诀窍，使用此功能时，您的里程数可能会有所不同。

>>> m = MultiPolygon(polygons)
>>> m.area
7.6845438018375516
>>> m.is_valid
False
>>> unary_union(m).area
6.6103013551167971
>>> unary_union(m).is_valid
True

shapely.ops.cascaded_union(geoms)¶: 返回给定几何对象的并集的表示形式。

备注

在1.8.0中 shapely.ops.cascaded_union() 已弃用，因为它已被取代 shapely.ops.unary_union() .

Delaunay三角测量¶

这个 triangulate() 中的函数 shapely.ops 从点集合计算Delaunay三角测量。

（ Source code ， png ， hires.png ， pdf ）

shapely.ops.triangulate(geom, tolerance=0.0, edges=False)¶

返回输入几何体顶点的Delaunay三角剖分。

源可以是任何几何类型。几何体的所有顶点将用作三角测量的点。

这个 tolerance 关键字参数设置用于提高三角测量计算的鲁棒性的捕捉公差。公差0.0指定不会发生捕捉。

如果 edges 关键字参数为 False 一览表 Polygon 将返回三角形。否则将列出 LineString 返回边。

New in version 1.4.0

>>> from shapely.ops import triangulate
>>> points = MultiPoint([(0, 0), (1, 1), (0, 2), (2, 2), (3, 1), (1, 0)])
>>> triangles = triangulate(points)
>>> pprint([triangle.wkt for triangle in triangles])
['POLYGON ((0 2, 0 0, 1 1, 0 2))',
 'POLYGON ((0 2, 1 1, 2 2, 0 2))',
 'POLYGON ((2 2, 1 1, 3 1, 2 2))',
 'POLYGON ((3 1, 1 1, 1 0, 3 1))',
 'POLYGON ((1 0, 1 1, 0 0, 1 0))']

诺图¶

这个 voronoi_diagram() 中的函数 shapely.ops 从集合点或任何几何体的顶点构造Voronoi图。

(Source code _, png ， hires.png ， pdf ）

shapely.ops.voronoi_diagram(geom, envelope=None, tolerance=0.0, edges=False)¶

从输入几何体的顶点构造Voronoi图。

源可以是任何几何体类型。几何体的所有顶点将用作图表的输入点。

这个 envelope keyword argument提供一个信封，用于剪辑生成的图表。如果 None ，将自动计算。图表将被剪辑到 更大的 提供的信封或网站周围的信封。

这个 tolerance 关键字参数设置用于提高计算稳健性的捕捉容差。公差0.0指定不会发生捕捉。容忍度 argument 可能是挑剔的，已知会导致算法在几种情况下失败。如果你使用 tolerance 如果失败了，试着把它去掉。中的测试用例 tests/test_voronoi_diagram.py 显示更多详细信息。

如果 edges 关键字参数为 False 一览表 Polygon s将被返回。否则 LineString 返回边。

>>> from shapely.ops import voronoi_diagram
>>> points = MultiPoint([(0, 0), (1, 1), (0, 2), (2, 2), (3, 1), (1, 0)])
>>> regions = voronoi_diagram(points)
>>> pprint([region.wkt for region in regions])
['POLYGON ((2 1, 2 0.5, 0.5 0.5, 0 1, 1 2, 2 1))',
 'POLYGON ((6 5, 6 -3, 3.75 -3, 2 0.5, 2 1, 6 5))',
 'POLYGON ((0.5 -3, -3 -3, -3 1, 0 1, 0.5 0.5, 0.5 -3))',
 'POLYGON ((3.75 -3, 0.5 -3, 0.5 0.5, 2 0.5, 3.75 -3))',
 'POLYGON ((-3 1, -3 5, 1 5, 1 2, 0 1, -3 1))',
 'POLYGON ((1 5, 6 5, 2 1, 1 2, 1 5))']

抢购¶

这个 snap() 中的函数 shapely.ops 将一个几何体中的顶点捕捉到具有给定公差的第二个几何体中的顶点。

shapely.ops.snap(geom1, geom2, tolerance)¶

捕捉顶点 geom1 到中的顶点 geom2. 将返回捕捉的几何图形的副本。不修改输入几何图形。

这个 tolerance 参数指定要捕捉的顶点之间的最小距离。

New in version 1.5.0

>>> from shapely.ops import snap
>>> square = Polygon([(1,1), (2, 1), (2, 2), (1, 2), (1, 1)])
>>> line = LineString([(0,0), (0.8, 0.8), (1.8, 0.95), (2.6, 0.5)])
>>> result = snap(line, square, 0.5)
>>> result.wkt
'LINESTRING (0 0, 1 1, 2 1, 2.6 0.5)'

共享路径¶

这个 shared_paths() 中的函数 shapely.ops 查找两个线性几何图形之间的共享路径。

shapely.ops.shared_paths(geom1, geom2)¶

查找之间的共享路径 geom1 和 geom2, 两个几何图形的位置 LineStrings.

A GeometryCollection 返回两个元素。第一个元素是 MultiLineString 包含两个输入方向相同的共享路径。第二个元素是包含两个输入的共享路径的多行字符串。

New in version 1.6.0

>>> from shapely.ops import shared_paths
>>> g1 = LineString([(0, 0), (10, 0), (10, 5), (20, 5)])
>>> g2 = LineString([(5, 0), (30, 0), (30, 5), (0, 5)])
>>> forward, backward = shared_paths(g1, g2)
>>> forward.wkt
'MULTILINESTRING ((5 0, 10 0))'
>>> backward.wkt
'MULTILINESTRING ((10 5, 20 5))'

分裂¶

这个 split() 中的函数 shapely.ops 将一个几何体拆分为另一个几何体。

shapely.ops.split(geom, splitter)¶

将一个几何体拆分为另一个几何体，并返回一组几何体。这个函数在理论上与分割几何零件的并集相反。如果拆分器不拆分几何体，则返回一个具有等于输入几何体的单个几何体的集合。

该功能支持：

用（多）点或（多）线串或（多）多边形边界分割（多）线串
用线串分割（多）多边形

在几何公差较低的情况下，可以方便地对拆分器进行捕捉。例如，如果将一条线拆分为一个点，则该点必须正好位于该线上，才能正确拆分该线。当用多边形分割线时，多边形的边界用于操作。将一行拆分为另一行时，如果两行在某个段重叠，则会引发ValueError。

New in version 1.6.0

>>> pt = Point((1, 1))
>>> line = LineString([(0,0), (2,2)])
>>> result = split(line, pt)
>>> result.wkt
'GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), LINESTRING (1 1, 2 2))'

子字符串¶

这个 substring() 中的函数 shapely.ops 返回沿 LineString .

shapely.ops.substring(geom, start_dist, end_dist[, normalized=False])¶

返回 LineString 之间 start_dist 和 end_dist 或A Point 如果他们在同一地点

负距离值被视为从几何体末端反向测量的值。超出范围的索引值通过将其限制在有效值范围内来处理。

如果起点距离等于终点距离，则返回一个点。

如果起始距离实际超过结束距离，则返回反转的子字符串，使起始距离位于第一个坐标。

如果规范化参数为 True ，该距离将被解释为几何体长度的一部分

New in version 1.7.0

下面是一些返回的示例 LineString 几何学。

>>> from shapely.geometry import LineString
>>> from shapely.ops import substring
>>> ls = LineString((i, 0) for i in range(6))
>>> ls.wkt
'LINESTRING (0 0, 1 0, 2 0, 3 0, 4 0, 5 0)'
>>> substring(ls, start_dist=1, end_dist=3).wkt
'LINESTRING (1 0, 2 0, 3 0)'
>>> substring(ls, start_dist=3, end_dist=1).wkt
'LINESTRING (3 0, 2 0, 1 0)'
>>> substring(ls, start_dist=1, end_dist=-3).wkt
'LINESTRING (1 0, 2 0)'
>>> substring(ls, start_dist=0.2, end_dist=-0.6, normalized=True).wkt
'LINESTRING (1 0, 2 0)'

下面是一个返回 Point .

>>> substring(ls, start_dist=2.5, end_dist=-2.5)
'POINT (2.5 0)'

准备好的几何操作¶

形状几何图形可以被处理成支持更有效批操作的状态。

prepared.prep(ob)¶: 创建并返回准备好的几何对象。

要针对大量点测试一个多边形容器，应首先使用 prepared.prep() 功能。

>>> from shapely.geometry import Point
>>> from shapely.prepared import prep
>>> points = [...] # large list of points
>>> polygon = Point(0.0, 0.0).buffer(1.0)
>>> prepared_polygon = prep(polygon)
>>> prepared_polygon
<shapely.prepared.PreparedGeometry object at 0x...>
>>> hits = filter(prepared_polygon.contains, points)

准备好的几何体实例具有以下方法： contains ， contains_properly ， covers 和 intersects . 所有的参数和用法都与未准备好的几何对象中的对应参数和用法完全相同。

诊断学¶

validation.explain_validity(ob):

返回解释对象有效性或无效性的字符串。

New in version 1.2.1.

消息可能有也可能没有可以解析出的问题点的表示。

>>> coords = [(0, 0), (0, 2), (1, 1), (2, 2), (2, 0), (1, 1), (0, 0)]
>>> p = Polygon(coords)
>>> from shapely.validation import explain_validity
>>> explain_validity(p)
'Ring Self-intersection[1 1]'

validation.make_valid(ob)¶

返回几何体的有效表示形式（如果无效）。如果有效，将返回输入几何图形。

在许多情况下，为了创建有效的几何图形，必须将输入几何图形拆分为多个零件或多个几何图形。如果必须将几何体拆分为同一几何体类型的多个部分，则将返回多部分几何体（例如多多边形）。如果必须将几何体拆分为不同类型的多个部分，则将返回GeometryCollection。

例如，对具有领结结构的几何体执行此操作：

>>> from shapely.validation import make_valid
>>> coords = [(0, 0), (0, 2), (1, 1), (2, 2), (2, 0), (1, 1), (0, 0)]
>>> p = Polygon(coords)
>>> str(make_valid(p))
'MULTIPOLYGON (((0 0, 0 2, 1 1, 0 0)), ((1 1, 2 2, 2 0, 1 1)))'

Yields a MultiPolygon with two parts:

(Source code _, png ， hires.png ， pdf )

_images/make_valid_multipolygon.png — 而此操作：¶

>>> from shapely.validation import make_valid
>>> coords = [(0, 2), (0, 1), (2, 0), (0, 0), (0, 2)]
>>> p = Polygon(coords)
>>> str(make_valid(p))

Yields a GeometryCollection with a Polygon and a LineString:

(Source code _, png ， hires.png ， pdf )

_images/make_valid_geometrycollection.png — New in version 1.8 Requires GEOS > 3.8¶

可通过访问shapely版本、geos库版本和geos c api版本 shapely.__version__ ， shapely.geos.geos_version_string 和 shapely.geos.geos_capi_version .

>>> import shapely
>>> shapely.__version__
'1.3.0'
>>> import shapely.geos
>>> shapely.geos.geos_version
(3, 3, 0)
>>> shapely.geos.geos_version_string
'3.3.0-CAPI-1.7.0'

多段标签¶

shapely.ops.polylabel(polygon, tolerance)¶

找到给定多边形的不可接近极点的近似位置。根据弗拉基米尔·阿加方金的 polylabel.

New in version 1.6.0

备注

1.7之前 polylabel 必须从导入 shapely.algorithms.polylabel 而不是 shapely.ops .

>>> from shapely.ops import polylabel
>>> polygon = LineString([(0, 0), (50, 200), (100, 100), (20, 50),
... (-100, -20), (-150, -200)]).buffer(100)
>>> label = polylabel(polygon, tolerance=10)
>>> label.wkt
'POINT (59.35615556364569 121.8391962974644)'

str压缩r-树¶

Shapely为使用Sort Tile递归算法打包的仅查询GEOS R-tree提供了一个接口。将几何对象的列表传递给STRtree构造函数，以创建一个可以使用其他几何对象查询的空间索引。查询只意味着一旦创建 STRtree 是不变的。不能添加或删除几何图形。

class strtree.STRtree(geometries)¶

这个 STRtree 构造函数接受一系列几何对象。

对这些几何对象的引用被保存并存储在R树中。

New in version 1.4.0.

strtree.query(geom)¶

返回中所有几何图形的列表 strtree 其范围与 geom . 这意味着，可能需要使用所需的二进制谓词（例如相交、交叉、包含、重叠）对返回的子集进行后续搜索，以便根据结果的特定空间关系进一步过滤结果。

>>> from shapely.strtree import STRtree
>>> points = [Point(i, i) for i in range(10)]
>>> tree = STRtree(points)
>>> query_geom = Point(2,2).buffer(0.99)
>>> [o.wkt for o in tree.query(query_geom)]
['POINT (2 2)']
>>> query_geom = Point(2, 2).buffer(1.0)
>>> [o.wkt for o in tree.query(query_geom)]
['POINT (1 1)', 'POINT (2 2)', 'POINT (3 3)']
>>> [o.wkt for o in tree.query(query_geom) if o.intersects(query_geom)]
['POINT (2 2)']

备注

要获取查询结果的原始索引，请创建一个辅助字典。但是使用几何图形 ids 因为shapely几何体本身是不可散列的。

>>> index_by_id = dict((id(pt), i) for i, pt in enumerate(points))
>>> [(index_by_id[id(pt)], pt.wkt) for pt in tree.query(Point(2,2).buffer(1.0))]
[(1, 'POINT (1 1)'), (2, 'POINT (2 2)'), (3, 'POINT (3 3)')]

strtree.nearest(geom)¶

返回中最近的几何体 strtree 到 geom .

>>> tree = STRtree([Point(i, i) for i in range(10)])
>>> tree.nearest(Point(2.2, 2.2)).wkt
'Point (2 2)'

互操作¶

shapely提供了4种与其他软件进行互操作的途径。

众所周知的格式¶

A Well Known Text （WKT）或 Well Known Binary （WKB）代表 1 任何几何物体的 wkt 或 wkb 属性。这些表示允许与许多GIS程序交换。例如，Postgis使用十六进制编码的wkb进行交易。

>>> Point(0, 0).wkt
'POINT (0.0000000000000000 0.0000000000000000)'
>>> Point(0, 0).wkb.encode('hex')
'010100000000000000000000000000000000000000'

这个 shapely.wkt 和 shapely.wkb 模块提供 dumps() and loads() functions that work almost exactly as their pickle 和 simplejson 模块副本。要将几何对象序列化为二进制或文本字符串，请使用 dumps() . 要反序列化字符串并获取适当类型的新几何对象，请使用 loads() .

wkt属性和 shapely.wkt.dumps() 功能不同。默认情况下，属性的值会被去掉多余的小数，而对于 dumps() ，但可以通过设置 trim=True .

shapely.wkb.dumps(ob)¶: 返回wkb表示形式 ob.

shapely.wkb.loads(wkb)¶: 从WKB表示返回几何对象 wkb.

>>> from shapely import wkb
>>> pt = Point(0, 0)
>>> wkb.dumps(pt)
b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
>>> pt.wkb
b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
>>> pt.wkb_hex
'010100000000000000000000000000000000000000'
>>> wkb.loads(pt.wkb).wkt
'POINT (0 0)'

这些函数支持所有shapely的几何类型。

shapely.wkt.dumps(ob)¶: 返回WKT表示形式 ob . 有几个关键字参数可用于更改返回的WKT；有关更多详细信息，请参阅docstrings。

shapely.wkt.loads(wkt)¶: 从WKT表示返回几何对象 wkt.

>>> from shapely import wkt
>>> pt = Point(0, 0)
>>> thewkt = wkt.dumps(pt)
>>> thewkt
'POINT (0.0000000000000000 0.0000000000000000)'
>>> pt.wkt
'POINT (0 0)'
>>> wkt.dumps(pt, trim=True)
'POINT (0 0)'

numpy和python数组¶

具有坐标序列（point， LinearRing, LineString) 提供numpy数组接口，因此可以转换或适应numpy数组。

>>> from numpy import asarray
>>> asarray(Point(0, 0))
array([ 0.,  0.])
>>> asarray(LineString([(0, 0), (1, 1)]))
array([[ 0.,  0.],
       [ 1.,  1.]])

备注

提供的numpy数组接口不依赖于numpy本身。

相同类型几何对象的坐标可以作为标准的python数组 x 和 y 价值观通过 xy 属性。

>>> Point(0, 0).xy
(array('d', [0.0]), array('d', [0.0]))
>>> LineString([(0, 0), (1, 1)]).xy
(array('d', [0.0, 1.0]), array('d', [0.0, 1.0]))

这个 shapely.geometry.asShape() 函数系列可用于包装numpy坐标数组，以便在保持原始存储的同时，使用shapely对它们进行分析。一个1 x 2阵列可以适应一个点

>>> from shapely.geometry import asPoint
>>> pa = asPoint(array([0.0, 0.0]))
>>> pa.wkt
'POINT (0.0000000000000000 0.0000000000000000)'

一个n x 2数组可以适应一个线串

>>> from shapely.geometry import asLineString
>>> la = asLineString(array([[1.0, 2.0], [3.0, 4.0]]))
>>> la.wkt
'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'

也可以从n x 2阵列创建多边形和多点：

>>> from shapely.geometry import asMultiPoint
>>> ma = asMultiPoint(np.array([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]]))
>>> ma.wkt
'MULTIPOINT (1.1 2.2, 3.3 4.4, 5.5 6.6)'

>>> from shapely.geometry import asPolygon
>>> pa = asPolygon(np.array([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]]))
>>> pa.wkt
'POLYGON ((1.1 2.2, 3.3 4.4, 5.5 6.6, 1.1 2.2))'

python geo接口¶

任何提供类似geojson的对象 Python geo interface can be adapted and used as a Shapely geometry using the shapely.geometry.asShape() 或 shapely.geometry.shape() 功能。

shapely.geometry.asShape(context)¶: 将上下文调整为几何图形界面。坐标仍存储在上下文中。

shapely.geometry.shape(context)¶: 返回带有坐标的独立几何图形 copied 从上下文来看。

例如，字典：

>>> from shapely.geometry import shape
>>> data = {"type": "Point", "coordinates": (0.0, 0.0)}
>>> geom = shape(data)
>>> geom.geom_type
'Point'
>>> list(geom.coords)
[(0.0, 0.0)]

或简单的Placemark类型对象：

>>> class GeoThing:
...     def __init__(self, d):
...         self.__geo_interface__ = d
>>> thing = GeoThing({"type": "Point", "coordinates": (0.0, 0.0)})
>>> geom = shape(thing)
>>> geom.geom_type
'Point'
>>> list(geom.coords)
[(0.0, 0.0)]

几何对象的类geojson映射可以使用 shapely.geometry.mapping() .

shapely.geometry.mapping(ob)¶

返回带有坐标的独立几何图形 copied 从上下文来看。

New in version 1.2.3.

例如，使用相同的 GeoThing 班级：

>>> from shapely.geometry import mapping
>>> thing = GeoThing({"type": "Point", "coordinates": (0.0, 0.0)})
>>> m = mapping(thing)
>>> m['type']
'Point'
>>> m['coordinates']
(0.0, 0.0)}

性能¶

对所有操作都使用地理库。GEOS是用C++编写的，在很多应用程序中使用，您可以预期所有操作都是高度优化的。然而，创建具有许多坐标的新几何图形需要一些开销，这可能会减慢代码的速度。

在 1.2.10 版本加入.

这个 shapely.speedups 模块包含用C编写的性能增强。在安装过程中，当python可以访问编译器和geos开发头文件时，它们会自动安装。

您可以检查加速是否与 available 属性。启用加速呼叫 enable() . 您可以使用 disable() .

>>> from shapely import speedups
>>> speedups.available
True
>>> speedups.enable()

在 1.6.0 版本加入.

如果加速功能可用，则现在默认启用。您可以使用 enabled 属性。

>>> from shapely import speedups
>>> speedups.enabled
True

结论¶

我们希望您能享受并从中获益。本手册将定期更新和改进。其来源可从https://github.com/toblerity/shapely/tree/master/docs/获取。

工具书类¶

1(1,2,3,4,5): John R.Herring，ed.，“地理信息的OpenGIS实现规范-简单功能访问-第1部分：公共架构”，2006年10月。
2: M.J.Egenhofer和John R.Herring，地理数据库中区域、直线和点之间的二元拓扑关系分类，美国缅因大学，1991年。
3: E.Clementini、P.Di Felice和P.van Oosterom，“适合最终用户交互的一组形式拓扑关系”，第三届大型空间数据库国际研讨会（SSD）。计算机科学第692号讲座笔记，DavidAbel和Beng Chin Ooi，eds.，新加坡：Springer Verlag，1993年，第277-295页。
4(1,2,3): C.strobl，“三维扩展九交叉模型（de-9im）”，《地理信息系统百科全书》，S.Shekhar和H.Xiong，编辑，Springer，2008年，第240-245页。[Stobl PDF]
5: Martin Davis，“JTS技术规范”，2003年3月。〔JTS- PDF〕
6: David H.Douglas和Thomas K.Peucker，“减少代表数字化线或其漫画所需点数的算法”，《制图：国际地理信息和地理可视化杂志》，第10卷，1973年12月，第112-122页。

Shapely用户手册¶

介绍¶

空间数据模型¶

关系¶

操作¶

坐标系¶

几何对象¶

一般属性和方法¶

点¶

LineStrings¶

LinearRings¶

多边形¶

收藏¶

积分集合¶

行集合¶

多边形集合¶

空功能¶

坐标序列¶

线性参考方法¶

谓词和关系¶

一元谓词¶

二元谓词¶

DE-9IM关系¶

空间分析方法¶

集合论方法¶

建设性方法¶

仿射转换¶

其他转换¶

其他业务¶

合并线性特征¶

高效的矩形裁剪¶

高效工会¶

Delaunay三角测量¶

诺图¶

最近点¶

抢购¶

共享路径¶

分裂¶

子字符串¶

准备好的几何操作¶

诊断学¶

多段标签¶

str压缩r-树¶

互操作¶

众所周知的格式¶

numpy和python数组¶

python geo接口¶

性能¶

结论¶

工具书类¶