Shapely

Shapely

  • 笛卡尔平面中几何对象的操作和分析
    • Shapely 是一个 BSD 许可的 Python 包，用于操作和分析平面几何对象。它使用广泛部署的开源几何库 GEOS（PostGIS 的引擎，JTS 的端口）。 Shapely 包装了 GEOS 几何图形和操作，为奇异（标量）几何图形提供功能丰富的几何接口，并为使用几何数组的操作提供更高性能的 NumPy ufunc。 Shapely 主要并不关注数据序列化格式或坐标系统，但可以轻松地与这些数据序列化格式或坐标系统集成。

1 概念引入

1.1 空间数据模型

Shapely 实现的几何对象的基本类型是点、曲线和曲面。每个点都与平面上的三组（可能是无限的）点相关联。特征的内部、边界和外部集合是互斥的，并且它们的并集与整个平面重合

1.1.1 点

  • 一个点有一个由一个点组成的内部集、一个由任何点组成的边界集以及一个由所有其他点组成的外部集
    • 点的拓扑维数为 0
    • 点类型由Point类实现

1.1.2 曲线

  • 曲线具有一个由沿其长度的无限多个点组成的内部集（想象一个在空间中拖动的点）、一个由其两个端点组成的边界集以及一个由所有其他点组成的外部集
    • 曲线的拓扑维数为 1
    • 曲线类型由 LineString 和 LinearRing 类绘制

1.1.3 曲面

  • 曲面具有一个由无限多个点组成的内部集（想象在空间中拖动一条曲线以覆盖一个区域）、一个由一条或多条曲线组成的边界集，以及一个由所有其他点组成的外部集，包括可能存在的孔内的点存在于表面
    • 曲面的拓扑维数为 2
    • 曲面由 Polygon 类组成

1.2 其他

  • Shapely 实现不平滑（即具有连续切线）的曲线
    • 所有曲线必须由线性样条曲线近似
  • 所有圆形面片必须由线性样条界定的区域来近似
  • 点集合由 MultiPoint 类实现
  • 曲线集合由 MultiLineString 类实现
  • 曲面集合由 MultiPolygon 类实现

2 方法

2.1 一般属性和方法

属性和方法 说明 备注
object.area 返回对象的面积 (float)
object.bounds 返回一个限制对象的 (minx, miny, maxx, maxy) 元组 (float)
object.length 返回对象的长度
object.minimum_clearance 返回节点可以移动以产生无效几何图形的最小距离 如果几何体（例如点）不存在最小间隙，则将返回 math.infinity 1.1
object.geom_type 返回指定对象的几何类型
object.distance 返回到其他几何对象的最小距离
object.hausdorff_distance 返回到其他几何对象的豪斯多夫距离 豪斯多夫距离1.2
object.representative_point 返回一个保证位于几何对象内的廉价计算点 这通常与质心不同
1.1. 这可以被认为是几何形状稳健性的衡量标准，其中最小间隙值越大表示几何形状越稳健 ↩
1.2. 两个几何图形之间的豪斯多夫距离是任一几何图形上的点距另一个几何图形上最近的点的最远距离 ↩

2.2 Points

属性和方法 说明 备注
class Point Point 构造函数采用位置坐标值或点元组参数 其他说明
point.area 点的面积为0
point.length 点的长度为0
point.bounds x-y 边界框是一个 (minx, miny, maxx, maxy) 元组
point.coords 坐标值可通过 coords、x、y和 z属性访问
point.coords[:] 坐标也可以被切片 1.2.14 版本中的新增功能2.1
Point(point) Point 构造函数还接受另一个 Point 实例，从而制作一个副本
2.1. 切片示例 ↩ 
1
2
>>> point.coords[:]
[(0.0, 0.0)]

2.3 LineStrings

属性和方法 说明 备注
class LineString LineString 构造函数采用 2 个或更多 (x, y[, z]) 点元组的有序序列 构造的 LineString 对象表示点之间的一个或多个连接的线性样条线。有序序列中的重复点是允许的，但可能会导致性能损失，应避免。 LineString 可以与自身交叉（即复杂而不简单）
line.area LineString 的面积为零长度非零
line.length LineString 的长度非零
line.bounds 它的 x-y 边界框是一个 (minx, miny, maxx, maxy) 元组
line.coords 定义的坐标值可通过 coords 属性访问
line.coords[:] 坐标也可以被切片 1.2.14 版本中的新增功能
LineString(line) 构造函数还接受另一个 LineString 实例，从而制作一个副本
LineString([Point(0.0, 1.0), (2.0, 3.0), Point(4.0, 5.0)]) LineString 也可以使用一系列混合 Point 实例或坐标元组来构造 各个坐标被复制到新对象中

2.4 LinearRings

属性和方法 说明 备注
class LinearRing LinearRing 构造函数采用 (x, y[, z]) 点元组的有序序列 通过在第一个和最后一个索引中传递相同的值，可以显式地关闭该序列。否则，将通过将第一个元组复制到最后一个索引来隐式关闭序列。与 LineString 一样，允许有序序列中的重复点，但可能会导致性能损失，应避免。 LinearRing 不能与自身交叉，也不能在一个点处接触自身4.1。
ring.area LinearRing 的面积为零
ring.length LinearRing 的长度非零
ring.bounds x-y 边界框是一个 (minx, miny, maxx, maxy) 元组
ring.coords 定义坐标值可通过 coords 属性访问
LinearRing(ring) LinearRing 构造函数还接受另一个 LineString 或 LinearRing 实例，从而制作一个副本 与 LineString 一样，Point 实例序列不是有效的构造函数参数
4.1. Shapely 不会阻止创建此类环，但在对其进行操作时会引发异常 ↩

2.5 Polygons

2.5.1 Polygon

属性和方法 说明 备注
class Polygon Polygon 构造函数采用两个位置参数。第一个是 (x, y[, z]) 点元组的有序序列，其处理方式与 LinearRing 情况完全相同。第二个是可选的环状序列的无序序列，指定特征的内部边界或“孔” 有效多边形的环不能相互交叉，但只能在一个点处接触。同样，Shapely 不会阻止创建无效特征，但在对它们进行操作时会引发异常。
p.area 多边形具有非零面积
p.length 多边形具有非零长度
p.bounds x-y 边界框是一个 (minx, miny, maxx, maxy) 元组
list(p.exterior.coords) 外部属性访问组件外部环
list(polygon.interiors) 内部属性访问组件内部环
Polygon 构造函数还接受 LineString 和 LinearRing 的实例

2.5.2 Box

属性和方法 说明 备注
shapely.geometry.box(minx, miny, maxx, maxy, ccw=True) 根据提供的边界框值创建矩形多边形，默认情况下按逆时针顺序
shapely.geometry.polygon.orient 返回给定多边形的正确定向的副本。结果的带符号区域将具有给定的符号。符号 1.0 表示产品外环的坐标将逆时针方向，内环（孔）的坐标将顺时针方向。

2.6 Collections

2.6.1 基本集合

Shapely 提供了类似 freezeset 的、不可变的几何对象集合。集合可以是同类的（多点等）或异构的

属性和方法 说明 备注
lineString1.intersection(lineString2) 返回相交集合 \
c.geoms GeometryCollection 的成员可通过 geoms 属性访问

:key: 如果可能，最好使用下面描述的同类集合类型之一

2.6.2 Collections of Points

属性和方法 说明 备注
class MultiPoint MultiPoint 构造函数采用一系列 (x, y[, z ]) 点元组
points.area 多点的面积为零
points.length 多点的长度为零
points.bounds x-y 边界框是一个 (minx, miny, maxx, maxy) 元组
list(points.geoms) 成员可通过 geoms 属性访问
MultiPoint([Point(0, 0), Point(1, 1)]) 构造函数还接受另一个 MultiPoint 实例或 Point 实例的无序序列，从而进行复制

2.6.3 Collections of Lines

属性和方法 说明 备注
class MultiLineString MultiLineString 构造函数采用一系列类似线的序列或对象 lines = MultiLineString([((0, 0), (1, 1)), ((-1, 0), (1, 0))])
lines.area MultiLineString 的面积为零
lines.length MultiLineString 的长度非零
lines.bounds x-y 边界框是一个 (minx, miny, maxx, maxy) 元组
lines.geoms 成员是 LineString 的实例，可以通过 geoms 属性访
MultiLineString(lines) 构造函数还接受 MultiLineString 的另一个实例或 LineString 实例的无序序列，从而进行复制

2.6.4 Collections of Polygons

属性和方法 说明 备注
class MultiPolygon MultiPolygon 构造函数采用一系列外环和孔列表元组：[((a1, …, aM), [(b1, …, bN), …]), …]
polygons.bounds x-y 边界框是一个 (minx, miny, maxx, maxy) 元组
polygons.geoms 成员是 Polygon 的实例，可以通过 geoms 属性访问

2.6.5 Empty features

:key: “空”要素是指其点集与空集一致的要素；不是 None ，而是像 set([]) 。可以通过调用不带参数的各种构造函数来创建空功能。空特征几乎不支持任何操作。

2.7 坐标序列

属性和方法 说明 备注
xxx.coords 描述几何图形的坐标列表表示为 CoordinateSequence 对象 这些序列不应直接初始化，但可以从现有几何图形作为 Geometry.coords 属性进行访问
poly.exterior.coords 多边形的外环坐标序列
poly.interiors 多边形的每个内环坐标序列

2.8 线性参考方法

使用一维参考系统指定沿线性要素（例如 LineStrings 和 MultiLineStrings）的位置非常有用。 Shapely 支持基于长度或距离的线性参考，评估沿几何对象到给定点投影的距离，或沿对象给定距离处的点

属性和方法 说明 备注
object.interpolate(distance [, normalized=False]) 返回沿线性几何对象指定距离处的点 如果标准化 arg 为 True ，则距离将被解释为几何对象长度的一部分
object.project[other [, normalized=False]] 返回沿该几何对象到距离其他对象最近的点的距离 果标准化 arg 为 True ，则返回标准化为对象长度的距离。 project() 方法是 interpolate() 的逆方法

3 谓词和关系

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

3.1 一员谓词

属性和方法 说明 备注
object.has_z 如果要素不仅具有 x 和 y，而且还具有 3D（或所谓的 2.5D）几何图形的 z 坐标，则返回 True
object.is_ccw 如果坐标按逆时针顺序（以正号区域为边界），则返回 True 此方法仅适用于 LinearRing 对象
object.is_empty 如果要素的内部和边界（以点集术语）与空集重合，则返回 True
object.is_ring 如果是封闭且简单的 LineString ，则返回 True 。闭合特征的边界与空集重合 该属性适用于 LineString 和 LinearRing 实例
object.is_simple 如果特征不与自身相交，则返回 True 简单性测试仅对 LineStrings 和 LinearRings 有意义
object.is_valid 如果某个功能在意义上“有效”，则返回 True 有效性测试仅对多边形和多边形有意义。对于其他类型的几何图形，始终返回 True

3.2 二元谓词

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

属性和方法 说明 备注
object.__eq__(other) 如果两个对象具有相同的几何类型，并且两个对象的坐标精确匹配，则返回 True
object.equals(other) 如果对象的集合论边界、内部和外部与另一个对象一致，则返回 True
object.equals_exact(other, tolerance=0.0, normalize=False) 如果几何形状在给定公差范围内结构等效，则返回 True
object.contains(other) 如果 other 没有点位于对象外部且 other 内部至少有一个点位于对象内部，则返回 True 线的端点是其边界的一部分，因此不包含在内
object.covers(other) 如果 other 的每个点都是对象内部或边界上的点，则返回 True 与 object.contains(other) 类似，但其不要求 other 的任何内部点位于对象的内部
object.covered_by(other) 如果对象的每个点都是其他对象内部或边界上的点，则返回 True 这相当于 other.covers(object)
object.crosses(other) 如果对象的内部与另一个对象的内部相交但不包含它，并且相交的尺寸小于其中一个或另一个的尺寸，则返回 True 一条线不与它所包含的点相交
object.disjoint(other) 如果对象的边界和内部与另一个对象根本不相交，则返回 True 该谓词适用于所有类型，并且是 intersects() 的逆
object.intersects(other) 如果对象的边界或内部以任何方式与另一个对象的边界或内部相交，则返回 True 如果几何对象有任何共同的边界或内点，则它们相交
object.overlaps(other) 如果几何图形具有多个但并非所有公共点、具有相同的维度，并且几何图形内部的交集具有与几何图形本身相同的维度，则返回 True
object.touches(other) 如果对象至少有一个共同点并且其内部不与另一个对象的任何部分相交，则返回 Tru
object.within(other) 如果对象的边界和内部仅与另一个对象的内部（而不是其边界或外部）相交，则返回 True

4 空间分析方法

4.1 集合论方法

几乎每个二元谓词方法都有一个返回新几何对象的对应方法。此外，对象的集合论边界可作为只读属性使用。

属性和方法 说明 备注
object.boundary 返回表示对象的集合论边界的低维对象 多边形的边界是一条线，线的边界是点的集合。点的边界是一个空集合
object.centroid 返回对象几何质心（点）的表示
object.difference(other)
p1 minus p2
p1 - p2		 返回构成此几何对象但不构成其他对象的点的表示
object.intersection(other)
p1 and p2
p1 & p2		 返回此对象与其他几何对象的交集的表示
object.symmetric_difference(other)
p1 xor p2
p1 ^ p2		 返回该对象中不属于其他几何对象中的点以及其他不属于该几何对象中的点的表示
object.union(other)
p1 or p2
p1		 p2` 返回此对象和另一个几何对象的点并集的表示

4.2 构造方法

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

属性和方法 说明 备注
object.buffer(distance, quad_segs=16, cap_style=1, join_style=1, mitre_limit=5.0, single_sided=False) 返回该几何对象给定距离内所有点的近似表示 点的解释4.2.1
distance 距离 正距离具有膨胀效果；负距离，侵蚀效果
quad_segs 定用于围绕点近似四分之一圆的线段数 可选参数
shapely.BufferCapStyle round-1, flat-2, square-3
shapely.BufferJoinStyle round-1, mitre-2, bevel-3 mitre-斜接
bevel-斜角
single_sided 单侧缓冲区 正距离表示左侧
负距离表示右侧
object.convex_hull 返回包含对象中所有点的最小凸多边形的表示，除非对象中的点数少于三个。 对于两个点，凸包折叠成一个 LineString；对于 1，一个点
object.envelope 返回包含对象的点或最小矩形多边形（边平行于坐标轴）的表示形式
object.minimum_rotated_rectangle 返回包含该对象的一般最小外接矩形。与包络不同，该矩形不限于平行于坐标轴。如果对象的凸包是简并（线或点），则返回该简并
object.parallel_offset(distance, side, resolution=16, join_style=1, mitre_limit=5.0) 返回距其右侧或左侧对象一定距离的 LineString 或 MultiLineString 几何图形 建议使用 offset_curve() 代替
object.offset_curve(distance, quad_segs=16, join_style=1, mitre_limit=5.0) 返回距其右侧或左侧对象一定距离的 LineString 或 MultiLineString 几何图形 参数说明4.2.2
此方法仅适用于 LinearRing 和 LineString 对象
object.simplify(tolerance, preserve_topology=True) 返回几何对象的简化表示。 简化对象中的所有点都将在原始几何体的公差距离内。默认情况下，使用较慢的算法来保留拓扑。如果保留拓扑设置为 False ，则使用更快的 Douglas-Peucker 算法
4.2.1. 以点作为示例 ↩
  • 点的默认缓冲区（quad_segs 为 16）是一个多边形面片，其面积占其近似圆盘面积的 99.8%
  • 当quad_segs为1时，缓冲区是一个方形补丁
  • 点几何形状的单面缓冲区与常规缓冲区相同。单面缓冲区的端盖样式始终被忽略，并强制为 BufferCapStyle.flat 的等效项。
4.2.2. 参数说明 ↩
  1. 距离参数必须是浮点值
  2. 边由距离参数的符号确定（负值表示右侧偏移，正值表示左侧偏移）。左和右是通过遵循 LineString 给定几何点的方向来确定的
  3. 对象每个顶点周围偏移的分辨率按照 buffer() 方法（使用quad_segs）进行参数化
  4. join_style 用于线段之间的外角。接受的整数值为 1（圆形）、2（斜接）和 3（斜角）
  5. 严重斜接的角可以通过 mitre_limit 参数

4.3 仿射变换

仿射变换函数的集合位于 shapely.affinity 模块中，它们通过直接向仿射变换矩阵提供系数或使用特定的命名变换（旋转、缩放等）来返回变换后的几何图形。这些函数可用于所有几何类型（GeometryCollection 除外），并且 3D 仿射变换会保留或支持 3D 类型。

  • shapely.affinity.affine_transform(geom, matrix)

    • 使用仿射变换矩阵返回变换后的几何图形

    • 系数 matrix 以列表或元组的形式提供，分别具有6个或12个项目，用于2D或3D变换

    • 对于2D仿射变换，第6个参数 matrix 为：[a, b, d, e, xoff, yoff]

      • 增广矩阵
        • image-20231018124613609
      • 变换后的坐标方程
        • image-20231018124620695

    • 对于3D仿射变换，12个参数 matrix 为：[a, b, c, d, e, f, g, h, i, xoff, yoff, zoff]

      • 增广矩阵
        • image-20231018124654269
        • 变换后的坐标方程
          • image-20231018124707640

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

    • 返回 2D 平面上的旋转几何体

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

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

      • 角度θ的二维旋转的仿射变换矩阵为
        • image-20231018124851716

    • 偏移量是从原点 $(x_0, y_0)$ 计算的

      • image-20231018124926392

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

    • 返回缩放后的几何图形，按每个维度上的因子进行缩放
    • 原点可以是表示 2D 边界框中心（默认）的关键字 'center' 、表示几何图形的 2D 质心的 'centroid' 、Point 对象或坐标元组 (x0, y0, z0)
    • 负比例因子将镜像或反映坐标

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

      • image-20231018125203603

    • 其中偏移量是从原点 $(x_0, y_0, z_0)$ 计算的

      • image-20231018125234304
  • shapely.affinity.skew(geom, xs=0.0, ys=0.0, origin='center', use_radians=False)
    • 返回一个倾斜的几何体，沿 x 和 y 维度被角度剪切
    • 可以通过设置 use_radians=True 以度数（默认）或弧度指定剪切角
    • 原点可以是边界框中心（默认）的关键字 'center' 、几何体质心的 'centroid' 、Point 对象或坐标元组 (x0, y0)
    • 倾斜的一般二维仿射变换矩阵为
      • image-20231018125332928
    • 其中偏移量是从原点 $(x_0, y_0$ 计算的
      • image-20231018125400863

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

    • 返回沿每个维度按偏移量移动的平移几何图形

    • 一般用于平移的 3D 仿射变换矩阵为

      • image-20231018125429111

4.4 其他操作

4.4.1 合并线性特征

  • shapely.ops.polygonize(lines)

    • 返回根据输入线构造的多边形的迭代器

    • 与 MultiLineString 构造函数一样，输入元素可以是任何线状对象

      • ```python
        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))
]
        list(polygonize(lines))
        [, ]
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30

        ---

        - `shapely.ops.polygonize_full(lines)`

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

            - 源可以是 MultiLineString、LineString 对象序列或可适应 LineString 的对象序列
            - 返回对象元组：（多边形、切边、悬垂物、无效环线）。每一个都是一个几何集合

          - 悬空是指一端或两端不与另一边端点重合的边。切边在两端相连，但不形成多边形的一部分。无效的环线形成无效的环（领结等）

            - ```python
              from shapely.ops import polygonize_full
              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, cuts, dangles, invalids = polygonize_full(lines)
              len(result.geoms)
              2
              list(result.geoms)
              [<POLYGON ((0 0, 1 1, 1 0, 0 0))>, <POLYGON ((1 1, 0 0, 0 1, 1 1))>]
              list(dangles.geoms)
              [<LINESTRING (1 1, 100 100)>, <LINESTRING (5 5, 6 6)>]

  • shapely.ops.linemerge(lines)

    • 返回表示行的所有连续元素的合并的 LineString 或 MultiLineString

      • 与 shapely.ops.polygonize() 一样，输入元素可以是任何线状对象

    • ```python
      from shapely.ops import linemerge
      linemerge(lines)

      list(linemerge(lines).geoms)
      [,
      ,
      ,
      ,
      ]

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16

      ### 4.4.2 高效的矩形裁剪

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

        - 几何体以快速但可能肮脏的方式被剪裁。不保证输出有效。拓扑错误不会引发任何异常

        - ```python
          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)
          clipped_polygon
          <POLYGON ((5 5, 5 15, 10 15, 10 10, 15 10, 15 5, 5 5))>

4.4.3 高效的并集

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

    • 返回给定几何对象的并集的表示

    • 重叠多边形的区域将被合并。 LineStrings 将完全溶解并节点化。重复的点将被合并

    • ```python
      from shapely.ops import unary_union
      polygons = [Point(i, 0).buffer(0.7) for i in range(5)]
      unary_union(polygons)

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95

      ---

      - `shapely.ops.cascaded_union(geoms)` ==已弃用==
        - 返回给定几何对象的并集的表示

      ### 4.4.4 德劳内三角剖分(Delaunay triangulation)

      - `shapely.ops.triangulate(geom, tolerance=0.0, edges=False)`
        - 返回输入几何体顶点的 Delaunay 三角剖分
        - 源可以是任何几何类型。几何体的所有顶点将用作三角剖分的点
        - Tolerance 关键字参数设置用于提高三角测量计算的鲁棒性的捕捉容差。容差 0.0 指定不会发生捕捉
        - 如果 Edge 关键字参数为 False，则将返回多边形三角形列表。否则返回 LineString 边的列表

      ![image-20231018130335202](https://s2.loli.net/2023/10/18/6ivyE7kCeSMVXH1.png)

      ### 4.4.5 沃罗诺伊图(Voronoi Diagram)

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

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

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

        - Envelope 关键字参数提供了一个用于剪辑结果图的信封。如果没有，则会自动计算。该图表将被剪切到所提供的信封或站点周围的信封中较大的一个

        - tolerance 关键字参数设置用于提高计算鲁棒性的捕捉容差。容差 0.0 指定不会发生捕捉。容差参数可能很挑剔，并且已知在某些情况下会导致算法失败。如果您使用容差并遇到失败，请尝试将其删除。 tests/test_voronoi_diagram.py 中的测试用例显示了更多详细信息

        - 如果 Edge 关键字参数为 False，则将返回多边形列表。否则返回`LineString 边的列表

          ![image-20231018130441507](https://s2.loli.net/2023/10/18/31HiXkWgZwQ7xCO.png)

      ### 4.4.6 最近的点

      - `shapely.ops.nearest_points(geom1, geom2)`
        - 返回输入几何中最近点的元组。点的返回顺序与输入几何图形的顺序相同

      ### 4.4.7 捕捉

      - `shapely.ops.snap(geom1, geom2, tolerance)`
        - 将 geom1 中的顶点捕捉到 geom2 中的顶点。返回捕捉的几何体的副本。输入几何形状未修改
        - 容差参数指定要捕捉的顶点之间的最小距离

      ### 4.4.8 共享路径

      - `shapely.ops.shared_paths(geom1, geom2)`
        - 查找 geom1 和 geom2 之间的共享路径，其中两个几何图形都是 LineString
        - 返回带有两个元素的 GeometryCollection。第一个元素是一个 MultiLineString，其中包含两个输入具有相同方向的共享路径。第二个元素是一个 MultiLineString，其中包含两个输入方向相反的共享路径。

      ### 4.4.9 分裂

      - `shapely.ops.split(geom, splitter)`
        - 将一个几何图形分割为另一个几何图形并返回几何图形的集合。该函数在理论上与分割几何部分的并集相反。如果分割器不分割几何图形，则返回具有等于输入几何图形的单个几何图形的集合
        - 该功能支持：
          - 通过（多）点或（多）线串或（多）多边形边界分割（多）线串
          - 通过线串分割（多）多边形
        - 以对几何形状的低公差来卡扣分离器可能会很方便。例如，在用点分割线的情况下，该点必须恰好在线上，才能正确分割线。当用多边形分割线时，将使用多边形的边界进行操作。当将一行与另一行分割时，如果两条线在某些段重叠，则会引发 ValueError 。

      ### 4.4.10 子串

      - `shapely.ops.substring(geom, start_dist, end_dist[, normalized=False])`
        - 返回 start_dist 和 end_dist 之间的 LineString 或 Point（如果它们位于同一位置）
        - 负距离值是从几何体末端沿相反方向测量的。超出范围的索引值通过将其限制在有效值范围内来处理
        - 如果起始距离等于结束距离，则返回一个点
        - 如果起始距离实际上超过了结束距离，则返回反转的子字符串，使得起始距离位于第一个坐标处
          - 如果标准化 arg 为 `True` ，则距离将被解释为几何形状长度的一部分

      ### 4.4.10 准备好的几何操作

      - `prepared.prep(ob)`

        - 形状优美的几何形状可以被处理成支持更高效的批量操作的状态
          - 要针对大量点测试一个多边形包含，应首先使用 `prepared.prep()` 函数

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

      ### 4.4.10 诊断

      - `validation.explain_validity(ob)`
        - 返回一个字符串，解释对象的有效性或无效性

      ---

      - `validation.make_valid(ob)`

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

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

        - ```python
          from shapely.validation import make_valid
          coords = [(0, 0), (0, 2), (1, 1), (2, 2), (2, 0), (1, 1), (0, 0)]
          p = Polygon(coords)
          make_valid(p)
          <MULTIPOLYGON (((1 1, 0 0, 0 2, 1 1)), ((2 0, 1 1, 2 2, 2 0)))>

    • image-20231018131233324

5 Numpy 和 Python 数组

1
2
3
4
5
6
7
8
9
10
11
>>> import numpy as np
>>> np.asarray(Point(0, 0).coords)
array([[0., 0.]])
>>> np.asarray(LineString([(0, 0), (1, 1)]).coords)
array([[0., 0.],
       [1., 1.]])

>>> 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]))

6 API 参考

Geometry API