## 二元谓词

``````object.almost_equals( other[, decimal=6])

``````

`object.contains(other)`

In [1]:
```from shapely.geometry import Point, LineString
coords = [(0, 0), (1, 1)]
LineString(coords).contains(Point(0.5, 0.5))
```
Out[1]:
`True`
In [2]:
```from shapely.geometry import LineString
Point(0.5, 0.5).within(LineString(coords))
```
Out[2]:
`True`

In [3]:
```LineString(coords).contains(Point(1.0, 1.0))
```
Out[3]:
`False`

In [4]:
```line = LineString(coords)
contained = filter(line.contains, [Point(), Point(0.5, 0.5)])
# len(contained)
```

`object.crosses(other)`

In [5]:
```LineString(coords).crosses(LineString([(0, 1), (1, 0)]))
```
Out[5]:
`True`

In [6]:
```LineString(coords).crosses(Point(0.5, 0.5))
```
Out[6]:
`False`

`object.disjoint(other)`

In [7]:
```Point(0, 0).disjoint(Point(1, 1))
```
Out[7]:
`True`

`object.equals(other)`

In [8]:
```from shapely.geometry import LineString
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)
```
Out[8]:
`True`
In [9]:
```b.equals(c)
```
Out[9]:
`True`

`object.intersects(other)`

`object.touches( other)`

In [10]:
```a = LineString([(0, 0), (1, 1)])
b = LineString([(1, 1), (2, 2)])
a.touches(b)
```
Out[10]:
`True`

`object.within(other)`

In [11]:
```from shapely.geometry import Point
from shapely.geometry import Polygon
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]

``````

In [12]:
```from shapely.geometry import asShape
class Within(object):
def __init__(self, o):
self.o = o
def __lt__(self, other):
return self.o.within(other.o)
```

``d > c``
In [13]:
```Within(d) > Within(c)
```
Out[13]:
`False`

In [14]:
```# [d, c, c, b, a] == sorted(features, key=Within, reverse=True)
```
In [ ]:
```
```

### DE九交空间(DE-9IM)关系

DE九交空间关系运算是用于检验2个几何对象的特定的拓扑空间关系的逻辑方法。 两个几何对象的拓扑空间关系在GIS中是一个重要的研究主题。 2个几何对象的拓扑空间关系的判断主要是通过几何对象的内部、边界和外部的交集。 在二维空间中，几何体的边界是比几何体更低一维的集合。 如点和多点的边界为空集。线的边界为线的2个端点， 当线是闭合时，则线的边界为空集。多边形（面）的边界是组成它的线。

#### 空间关系

1. 两个几何对象完全相同，则表示为DE-9IM即“TFFFTFFFT”
2. 两个对象的边界和内部都没有任何公共部分，则表示为DE-9IM即“FF*FF****”
3. Disjoint取反
4. 简单地说Touches表示两个对象的边缘相接触， 这个关系是以下几类几何对象间特有的：A/A, L/L, L/A, P/A ,P/L。 用DE-9IM表示为“FT*******”, “F**T*****”或“F***T****”
5. Crosses表示一个对象穿过另一个对象，它应用于P/L, P/A, L/L和L/A之间。 用DE-9IM表示为：“T*T******”（P/L, P/A,L/A），“0********”（L/L）
6. 包含于。用DE-9IM表示为：“T*F**F***”
7. 相叠，应用于A/A, L/L 和P/P之间。用DE-9IM表示为：“T*T***T**”（A/A, P/P），“1*T***T**”（L/L）
8. 包含，对立于Within。

JTS的Geometry类实现了上面的所有方法，由于这些方法不能表示全部的空间位置关系， 因此OGC的Simple Feature Specification和JTS都提供了一个`relate`方法， 用来测试指定的DE-9IM关系。

`relate()`方法测试了对象之间的所有DE九交空间关系。

`object.relate(other)` 返回在一个对象和另一个几何对象的内部、 边界和外部之间的DE九交空间关系。

In [15]:
```from shapely.geometry import Point
Point(0, 0).relate(Point(1, 1))
```
Out[15]:
`'FF0FFF0F2'`
In [16]:
```from shapely.geometry import LineString
Point(0, 0).relate(LineString([(0, 0), (1, 1)]))
```
Out[16]:
`'F0FFFF102'`

In [17]:
```LineString([(0, 0), (1, 1)]).relate(LineString([(0, 0), (1, 1)]))
```
Out[17]:
`'1FFF0FFF2'`
In [18]:
```Point(0, 0).relate(Point(0, 0))
```
Out[18]:
`'0FFFFFFF2'`
In [19]:
```Polygon([[0, 0], [0, 4], [4, 4], [4, 0]]).relate(Polygon([[0, 0], [0, 4], [4, 4], [4, 0]]))
```
Out[19]:
`'2FFF1FFF2'`

### 一元谓词

#### 一般的一元谓词

`object.has_z`: 如果要素不仅有x和y，还有z，则返回为‘True’。

In [20]:
```from shapely.geometry import Point
Point(0, 0).has_z
Point(0, 0, 0).has_z
```
Out[20]:
`True`

`object.is_ccw` : 如果坐标是逆时针的，返回为真 （用正面标记的面积来框定区域）。这种方法仅适用于线性对象。

``````LinearRing([(1,0), (1,1), (0,0)]).is_ccw

``````

In [21]:
```from shapely.geometry import LinearRing
ring = LinearRing([(0,0), (1,1), (1,0)])
ring.is_ccw
ring.coords = list(ring.coords)[::-1]
ring.is_ccw
```
Out[21]:
`True`

`object.is_empty`

In [22]:
```from shapely.geometry import Point
Point().is_empty
Point(0, 0).is_empty
```
Out[22]:
`False`

`operator`模块的`attrgetter()`函数的帮助，一元谓词例如 `is_empty`能够轻松地用作 `filter()`或者`itertools.ifilter()`内建的谓词。

In [23]:
```from operator import attrgetter
empties = filter(attrgetter('is_empty'), [Point(), Point(0, 0)])
# len(empties)
```

`object.is_ring`： 如果要素被闭合了，则返回为真。 一个关闭的要素的边界算是空集。

In [24]:
```from shapely.geometry import LineString
LineString([(0, 0), (1, 1), (1, -1)]).is_ring
```
Out[24]:
`False`
In [25]:
```from shapely.geometry import LinearRing
LinearRing([(0, 0), (1, 1), (1, -1)]).is_ring
```
Out[25]:
`True`

`object.is_simple` ： 如果要素不是自相交的，则返回为真。

In [26]:
```from shapely.geometry import LineString
LineString([(0, 0), (1, 1), (1, -1), (0, 1)]).is_simple
```
Out[26]:
`False`

Shapely完全支持线环（LineStrings）的操作。

`object.is_valid`： 如果一个要素是有效的，返回真。

In [27]:
```from shapely.geometry import MultiPolygon
MultiPolygon([Point(0, 0).buffer(2.0), Point(1, 1).buffer(2.0)]).is_valid
```
Out[27]:
`False`

`is_valid`谓词可以用来写一个验证修饰， 可以确保唯一有效的对象从构造函数中返回。

In [28]:
```import helper; helper.info()
```
```页面更新时间： 2019-02-28 18:43:10

Python: 3.5.3
```