Shapely用戶手冊?

作者:肖恩·吉利斯,<sean.gillies@gmail.com>
版本:1.6.4
日期:2019 年 07 月 02 日
版權:這項工作是根據 `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 類;曲線 LineStringLinearRing 等級;表面 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矩陣理解它們的理論框架。 [2] 是DE-9IM。有關de-9im關系的全面回顧見 [4] 本手冊將不再重復。

操作?

遵循JTS技術規范 [5] ,本手冊將對構造(buffer, convex hull) 并設置理論運算(intersection, union, 等等)。個人操作將在本手冊的以下章節中詳細描述。

坐標系?

盡管地球不是平的,也不完全是球形的,但有許多分析問題可以通過將地球特征轉換為笛卡爾平面、應用經過驗證的算法,然后將結果轉換回地理坐標來解決。這種做法與傳統的精確紙質地圖一樣古老。

shapely不支持坐標系轉換。對兩個或多個特征的所有操作都假定這些特征存在于同一笛卡爾平面中。

幾何對象?

幾何對象是以典型的Python方式創建的,使用類本身作為實例工廠。它們的一些內在屬性將在本節中討論,其他屬性將在下面的操作和序列化部分中討論。

實例 Point , LineStringLinearRing 有一個有限的坐標序列作為它們最重要的屬性,它決定了它們的內部、邊界和外部點集。一個字符串可以由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.geom_type?

返回一個指定 Geometry Type 根據 [1] .

>>> print Point(0, 0).geom_type
Point
object.distance(other)?

返回最小距離( floatother 幾何對象。

>>> Point(0,0).distance(Point(1,1))
1.4142135623730951
object.hausdorff_distance(other)?

返回Hausdorff距離 (floatother 幾何對象。兩個幾何體之間的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)

_images/linestring.png

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

_images/linearring.png

圖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 構造函數也接受另一個 LineStringLinearRing 實例,從而復制。

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

_images/polygon.png

圖3.在左邊,一個有效的 Polygon 帶有一個內環,在一個點與外環接觸,在右側A Polygon 那就是 invalid 因為它的內環與外環的接觸不止一個點。描述環的點以灰色顯示。

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

_images/polygon2.png

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

組件環通過 exteriorinteriors 性質。

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

這個 Polygon 構造函數還接受的實例 LineStringLinearRing.

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

_images/geometrycollection.png

圖5。a)一條綠色線和一條黃色線,沿著一條線和一個點相交;b)交叉點(藍色)是一個集合,其中包含一個 LineString 一個 Point.

A成員 GeometryCollection 通過訪問 geoms 屬性或通過迭代器協議使用 inlist() .

>>> 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 屬性或通過迭代器協議使用 inlist() .

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

_images/multilinestring.png

圖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 屬性或通過迭代器協議使用 inlist() .

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

_images/multipolygon.png

圖7.在左邊,A valid 多多邊形,有兩個成員,在右邊是 `MultiPolygon 這是無效的,因為它的成員接觸無限多的點(沿著一條線)。

它的 x-y 邊界框是一個 (minx, miny, maxx, maxy) 元組。

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

它的成員是 Polygon 并通過 geoms 屬性或通過迭代器協議使用 inlist() .

>>> len(polygons.geoms)
3
>>> len(polygons)
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>

線性參考方法?

沿著線性特征指定位置可能很有用,例如 LineStringsMultiLineStrings 具有一維參考系統。形狀支持基于長度或距離的線性引用,計算沿幾何對象到給定點投影的距離,或沿對象的給定距離處的點。

注解

線性參考方法需要GEOS 3.2.0或更高版本。

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] 謂詞作為屬性(用于一元謂詞)和方法(用于二元謂詞)。無論是一元還是二元,都返回 TrueFalse .

一元謂詞?

標準的一元謂詞實現為只讀屬性屬性。每個都將顯示一個示例。

object.has_z?

返回 True 如果功能不僅 xy, 而且 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 如果功能 interiorboundary (用點集術語)與空集一致。

>>> 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 如果功能關閉。關閉的功能 boundary 與空集重合。

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

此屬性適用于 LineStringLinearRing 實例,但對其他人來說毫無意義。

object.is_simple?

返回 True 如果特性本身沒有交叉。

注解

簡單性測試只對 LineStringsLinearRings.

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

非簡單操作 LineStrings 完全由形狀支持。

object.is_valid?

返回 True 如果某個功能在以下意義上是“有效的” [1] .

有效的 LinearRing 不能在一點上交叉或觸摸自己。有效的 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

二元謂詞?

標準的二進制謂詞作為方法實現。這些謂詞評估拓撲關系、集合理論關系。在一些情況下,結果可能不是人們從不同的假設開始所期望的。都以另一個幾何對象為參數并返回 TrueFalse .

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.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 如果 boundaryinterior 物體與另一物體完全不相交。

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

這個謂詞適用于所有類型,是 intersects() .

object.intersects(other)?

返回 True 如果 boundaryinterior 物體以任何方式與另一物體相交。

換句話說,如果幾何對象有任何共同的邊界或內部點,它們就會相交。

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 如果對象是 boundaryinterior 只與…相交 interior 另一個(不是 boundaryexterior) .

這適用于所有類型,與 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(object):
    def __init__(self, o):
        self.o = o
    def __lt__(self, other):
        return self.o.within(other.o)

正如Howto所說, less than 在排序時,保證使用比較。這就是我們在空間排序上所依賴的,也是我們使用的原因 within() 相反而不是 contains() . 在功能上嘗試 dc, 我們看到它起作用了。

>>> 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 , 12 )布爾匹配( TF )或通配符( * )例如,用于 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, 不 NoneFalse. 要測試非空結果,請使用幾何圖形的 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)

_images/difference.png

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

_images/intersection-sym-difference.png
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)

_images/union.png

注解

union() 是查找多個對象累積聯合的昂貴方法。見 shapely.ops.unary_union() 更有效的方法。

建設性方法?

形狀幾何對象有幾種方法可以產生新的對象,而不是從集合理論分析中推導出來的。

object.buffer(distance, resolution=16, cap_style=1, join_style=1, mitre_limit=5.0)?

返回給定中所有點的近似表示形式 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

正距離有膨脹的作用;負距離有侵蝕作用??蛇x的 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)

_images/buffer.png

圖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

通過 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)
2
>>> list(clean[0].exterior.coords)
[(0.0, 0.0), (0.0, 2.0), (1.0, 1.0), (0.0, 0.0)]
>>> list(clean[1].exterior.coords)
[(1.0, 1.0), (2.0, 2.0), (2.0, 0.0), (1.0, 1.0)]

緩沖在多邊形接觸點將多邊形分成兩部分。

object.convex_hull?

返回最小凸的表示形式 Polygon 包含對象中的所有點,除非對象中的點少于三個。對于兩個點,凸面外殼塌陷為 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)

_images/convex_hull.png

圖10。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?

返回包含該對象的常規最小邊框。與包絡不同,此矩形不受約束與坐標軸平行。如果對象的凸面外殼是退化(線或點),則返回該退化。

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)

_images/minimum_rotated_rectangle.png

圖11。多點功能(左)和線串功能(右)的最小旋轉矩形。

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

返回與對象右側或左側相距一定距離的LineString或MultiLineString幾何圖形。

距離必須為正浮點值。側邊參數可以是“Left”或“Right”。左、右是根據線串的給定幾何點的方向來確定的。在緩沖區方法中,對對象每個頂點周圍偏移的分辨率進行參數化。

連接樣式用于線段之間的外角。接受的整數值為1(圓形)、2(斜接)和3(斜接)。也見 shapely.geometry.JOIN_STYLE .

嚴重斜接角可以由mitre_limit參數控制(英文拼寫,en-gb)。從角到斜接偏移角末端的距離之比是斜接比率。比例超過限制的角將傾斜。

注解

此方法僅適用于 LinearRingLineString 物體。

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

_images/parallel_offset.png

圖12。簡單線條字符串左側(其起點顯示為圓)的三種平行偏移線樣式,右側的一種偏移為多部分。

影響 mitre_limit 參數如下所示。

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

_images/parallel_offset_mitre.png

圖13。左右偏移的大斜接和小斜接限制值。

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)

_images/simplify.png

圖14。使用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 x'y'1 結束BMatrix=開始BMatrix A&B&X Mathrm關閉D&E&Y Mathrm關閉0&0&1 結束BMatrix 開始BMatrix x\y\1 結束BMatrix\]

或轉換坐標的方程式:

\[x'&=a x+b y+x_ mathrm off y'&=d x+e y+y off。\]

對于三維仿射變換,12參數 matrix 是:

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

表示增廣矩陣:

\[開始BMatrix x'y'z'z'1結束BMatrix;=b e開始BMatrix A&B&C&C&X 123; Matherm關閉D&E&F&Y B&H&H&I&I&I&Z\ \Y 123; Y&F&F&F&Y \Z \1 結束B矩陣\]

或轉換坐標的方程式:

\[x'&=a x+b y+c z+x mathrm off y'&=d x+e y+f z+y mathrm off z'&=g x+h y+i z+z off。\]
shapely.affinity.rotate(geom, angle, origin='center', use_radians=False)?

返回二維平面上的旋轉幾何圖形。

旋轉角度可以通過設置指定為度(默認)或弧度。 use_radians=True . 正的角度是逆時針的,負的是順時針的旋轉。

原點可以是關鍵字 'center' 對于邊界框中心(默認), 'centroid' 對于幾何體的質心,a Point 對象或坐標元組 (x0, y0) .

二維帶角旋轉的仿射變換矩陣 \(\theta\) 是:

\[開始bmatrix cos theta&-sin theta&x mathrm off sin theta&cos theta&y mathrm off 0&0&1end bmatrix\]

從原點計算偏移量的位置 \((x_0, y_0)\)

\[x mathrm off&=x 0-x 0 cos theta+y+sin theta y mathrm off&=y 0-x 0 sin theta-y cos theta\]
>>> 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)

_images/rotate.png

圖15。A的旋轉 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 Mathrm事實&0&0&X Mathrm關閉0&Y事實&0&Y Mathrm關閉0&0&Z事實&Z Mathrm關閉0&0&0&1end BMatrix\]

從原點計算偏移量的位置 \((x_0, y_0, z_0)\)

\[x mathrm off&=x 0-x 0 x mathrm fact y mathrm off&=y y mathrm fact z mathrm off&=z 0-z mathrm fact\]
>>> 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)

_images/scale.png

圖16。將灰色三角形縮放為藍色結果: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 1&tan x x mathrm off tan y&1&y mathrm off 0&0&1end BMatrix\]

從原點計算偏移量的位置 \((x_0, y_0)\)

\[X關閉&=-Y關閉&=-X Y關閉&=-X 0 Y U S\]

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

_images/skew.png

圖17?;疑癛”到藍色的傾斜結果:a)沿X方向的剪切角為20°,原點位于(1,1);b)沿Y方向的剪切角為30°,使用默認原點。

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

返回沿每個維度偏移的已轉換幾何圖形。

一般用于翻譯的三維仿射變換矩陣為:

\[開始BMatrix 1&0&0&X關閉0&1&0&Y關閉0&0&1&Z關閉0&0&0&1end BMatrix\]

其他轉換?

形狀支持地圖投影和幾何對象的其他任意轉換。

shapely.ops.transform(func, geom)?

應用 func 到的所有坐標 geom 并從轉換后的坐標中返回相同類型的新幾何圖形。

func 將X、Y和可選Z映射到輸出xp、yp、zp。輸入參數可以是列表、數組或單個值等可重復的類型。輸出應為同一類型:scalars-in、scalars-out、list-in、list-out。

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部分應用的轉換函數滿足 func.

from shapely.ops import transform
from functools import partial
import pyproj

project = partial(
    pyproj.transform,
    pyproj.Proj(init='epsg:4326'),
    pyproj.Proj(init='epsg:26913'))

g2 = transform(project, g1)

lambda表達式,例如

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

同時滿足以下要求: func.

其他業務?

合并線性特征?

觸摸線的序列可以合并到 MultiLineStringsPolygons 在中使用函數 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)
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 LineStringMultiLineString 表示所有相鄰元素的合并 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...>]

高效工會?

這個 unary_union() 中的函數 shapely.ops 比積累更有效 union() .

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

_images/unary_union.png
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.2.16中 shapely.ops.cascaded_union() 顯然被 shapely.ops.unary_union() 如果使用GEOS 3.3+。一元聯合函數可以在不同的幾何體類型上操作,而不僅僅是像舊的級聯聯合那樣的多邊形。

Delaunay三角測量?

這個 triangulate() 中的函數 shapely.ops 從點集合計算Delaunay三角測量。

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

_images/triangulate.png
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))']

最近點?

這個 nearest_points() 中的函數 shapely.ops 計算一對幾何圖形中最近的點。

shapely.ops.nearest_points(geom1, geom2)?

返回輸入幾何圖形中最近點的元組。返回點的順序與輸入幾何圖形的順序相同。

New in version 1.4.0.

>>> from shapely.ops import nearest_points
>>> triangle = Polygon([(0, 0), (1, 0), (0.5, 1), (0, 0)])
>>> square = Polygon([(0, 2), (1, 2), (1, 3), (0, 3), (0, 2)])
>>> [o.wkt for o in nearest_points(triangle, square)]
['POINT (0.5 1)', 'POINT (0.5 2)']

請注意,最近的點可能不是幾何體中的現有頂點。

搶購?

這個 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)?

查找之間的共享路徑 geom1geom2, 兩個幾何圖形的位置 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 返回沿線性幾何圖形的指定距離之間的線段。

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

負距離值被視為從幾何體末端反向測量的值。超出范圍的索引值通過將其限制在有效值范圍內來處理。

如果起點距離等于終點距離,則返回一個點。

如果規范化arg為真,則距離將被解釋為幾何體長度的一部分。

New in version 1.7.0

>>> line = LineString(([0, 0], [2, 0]))
>>> result = substring(line, 0.5, 0.6)
>>> result.wkt
'LINESTRING (0.5 0, 0.6 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 , coversintersects . 所有的參數和用法都與未準備好的幾何對象中的對應參數和用法完全相同。

診斷學?

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

可通過訪問shapely版本、geos庫版本和geos c api版本 shapely.__version__ , shapely.geos.geos_version_stringshapely.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'

str壓縮r-樹?

shapely為使用排序塊遞歸算法打包的僅查詢geos r-tree提供了接口。將幾何對象列表傳遞給strtree構造函數以創建一個R樹,您可以使用另一個幾何對象進行查詢。

class strtree.STRtree(geometries)?

這個 STRtree 構造函數接受一系列幾何對象。

它們被復制并存儲在R樹中。

New in version 1.4.0.

這個 query 方法對 STRtree 返回樹中與提供的幾何參數相交的所有幾何圖形的列表。如果要匹配更具體空間關系的幾何圖形(例如交叉、包含、重疊),請考慮在R樹上執行查詢,然后使用所需的二進制謂詞對返回的子集進行手動搜索。

查詢只意味著一旦創建,R樹是不可變的。不能添加或刪除幾何圖形。

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

互操作?

shapely提供了4種與其他軟件進行互操作的途徑。

眾所周知的格式?

A Well Known Text (WKT)或 Well Known Binary (WKB)代表 [1] 任何幾何物體的 wktwkb 屬性。這些表示允許與許多GIS程序交換。例如,Postgis使用十六進制編碼的wkb進行交易。

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

這個 shapely.wktshapely.wkb 模塊提供 dumps() and loads() functions that work almost exactly as their picklesimplejson 模塊副本。要將幾何對象序列化為二進制或文本字符串,請使用 dumps() . 要反序列化字符串并獲取適當類型的新幾何對象,請使用 loads() .

shapely.wkb.dumps(ob)?

返回wkb表示形式 ob.

shapely.wkb.loads(wkb)?

從WKB表示返回幾何對象 wkb.

>> from shapely.wkb import dumps, loads
>>> wkb = dumps(Point(0, 0))
>>> print wkb.encode('hex')
010100000000000000000000000000000000000000
>>> loads(wkb).wkt
'POINT (0.0000000000000000 0.0000000000000000)'

這些函數支持所有shapely的幾何類型。

shapely.wkt.dumps(ob)?

返回WKT表示形式 ob.

shapely.wkt.loads(wkt)?

從WKT表示返回幾何對象 wkt.

>> from shapely.wkt import dumps, loads
>> wkt = dumps(Point(0, 0))
>>> print wkt
POINT (0.0000000000000000 0.0000000000000000)
>>> loads(wkt).wkt
'POINT (0.0000000000000000 0.0000000000000000)'

numpy和python數組?

具有坐標序列(point, LinearRing, LineString) 提供numpy數組接口,因此可以轉換或適應numpy數組。

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

這個 numpy.asarray() 函數不復制坐標值——代價是對形狀對象的坐標進行緩慢的numpy訪問。

注解

提供的numpy數組接口不依賴于numpy本身。

相同類型幾何對象的坐標可以作為標準的python數組 xy 價值觀通過 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(object):
...     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](1, 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月?!睯TS- PDF〕
[6]David H.Douglas和Thomas K.Peucker,“減少代表數字化線或其漫畫所需點數的算法”,《制圖:國際地理信息和地理可視化雜志》,第10卷,1973年12月,第112-122頁。