5.3. Tipos Geométricos em Python

A biblioteca Shapely fornece o modelo geométrico e as operações espaciais da OGC-SFS (Seção 5.2) com um estilo Pythonico. Ela utiliza a biblioteca C++ denominada GEOS para representação dos tipos geométricos bem como para as operações espaciais.

5.3.1. Instalação

Para realizar a instalação da Shapely com o gerenciador de pacotes da Anaconda, ative o ambiente virtual no qual deseja instalar a biblioteca e, em seguida, instale o pacote com o mesmo nome da biblioteca, como mostrado abaixo:

conda activate geospatial

conda install shapely

Para verificar se sua instalação foi realizada com sucesso, importe a biblioteca e verifique sua versão:

In [1]: import shapely

In [2]: shapely.__version__
Out[2]: '1.7.1'

Nota

Você deverá instalar a versão 1.7.1 ou superior.

5.3.2. Tipos Geométricos

A biblioteca Shapely suporta os tipos geométricos da OGC-SFS: Point, LineString, LinearRing, Polygon, MultiPoint, MultiLineString, MultiPolygon e GeometryCollection (Figura 5.3).

Como a biblioteca Shapely utiliza a GEOS, as operações suportadas não consideram a componente \(z\) em suas análises. Além disso, os tipos geométricos dessa biblioteca utilizam números em ponto flutuante para representação das coordenadas dos seus elementos geométricos.

5.3.2.1. Pontos (Point)

Para criar objetos do tipo Point é preciso importar esse tipo a partir do módulo geometry do pacote shapely:

from shapely.geometry import Point

O construtor de um objeto Point aceita um par de valores \(x\) e \(y\) e, opcionalmente, um valor de \(z\):

In [1]: pt = Point(5.0, 3.0)

As coordenadas de um ponto podem ser acessadas através dos atributos x e y:

In [1]: pt.x
Out[1]: 5.0

In [1]: pt.y
Out[1]: 3.0

Em um jupyter notebook a expressão abaixo apresenta um figura representando o ponto:

In [1]: pt

Nota

O desenho mostrado acima é possível pois o ambiente Jupyter reconhece que a expressão acima pode ser apresentada por uma figura em SVG.

5.3.2.2. Linhas (LineString)

Assim como o tipo Point, o tipo LineString deve ser importado da seguinte forma:

from shapely.geometry import LineString

O construtor de um objeto LineString aceita como argumento uma sequência de tuplas (x, y) ou (x, y, z):

line = LineString( [ (0, 0), (5, 2), (10, 9), (18, 10) ] )

As coordenadas x e y dos vértices da linha podem ser acessados na forma de arrays:

line.xy

Em um jupyter notebook a expressão abaixo apresenta um figura representando a linha:

line

Uma linha possui comprimento:

line.length

A fronteira da linha é formada pelos pontos inicial e final, portanto, por objetos \(0\)-dimensional:

line.boundary

Para acessar os elementos de uma linha podemos utilizar o atributo coords:

for c in line.coords:
    print(c)

Podemos usar a notação de slice de sequências com objetos do tipo LineString:

line.coords[0:2]

line.coords[1:]

5.3.2.3. Anel (LinearRing)

Para criar objetos do tipo LinearRing é preciso importar a classe LinearRing:

from shapely.geometry import LinearRing

O construtor de um objeto LinearRing aceita como argumento uma sequência de tuplas (x, y) ou (x, y, z):

anel = LinearRing( [ (0, 0), (10, 0), (10, 10), (0, 10), (0, 0) ] )

Nota

A sequência informada pode ser explicitamente fechada como no caso acima ou pode ser aberta. Neste último caso a sequência será implicitamente fechada.

Assim como no caso de linhas, as coordenadas de um anel podem ser acessadas na forma de arrays:

anel.xy

Em um jupyter notebook a expressão abaixo apresenta um figura representando o anel:

anel

Um anel possui comprimento:

anel.length

A fronteira de um anel é o conjunto vazio:

anel.boundary

5.3.2.4. Polígonos

Para criar objetos do tipo Polygon é preciso importar a classe Polygon:

from shapely.geometry import Polygon

O construtor de um objeto Polygon aceita dois argumentos. O primeiro, obrigatório, é uma sequência de tuplas (x, y) ou (x, y, z) que representa o anel externo do polígono. O segundo, opcional, é uma sequência de anéis e representa os anéis internos do polígono:

anel_externo = [ (0, 0), (10, 0), (10, 10), (0, 10), (0, 0) ]

anel_interno = [ (3, 3), (7, 3), (7, 7), (3, 7), (3, 3) ]

poly = Polygon(anel_externo, [anel_interno])

O anel externo pode ser acessado através do operador exterior:

poly.exterior

Os anéis internos podem ser acessados através da propriedade interiors:

poly.interiors

len(poly.interiors)

poly.interiors[0]

poly.interiors[0].xy

Em um jupyter notebook a expressão abaixo apresenta um figura representando o polígono:

poly

Um polígono possui comprimento:

poly.length

Um polígono possui área:

poly.area

A fronteira de um polígono é formada pelos anéis desse polígono, objetos \(1\)-dimensional:

poly.boundary

5.3.2.5. MultiPoint

Para criar objetos que representam coleções homogeneas de pontos é preciso importar a classe MultiPoint:

from shapely.geometry import MultiPoint

O construtor de um MultiPoint recebe como argumento uma sequência de valores (x, y) ou (x, y, z):

mpt = MultiPoint( [ (0, 0), (5, 5), (10, 0), (10, 10), (0, 10) ] )

Em um jupyter notebook a expressão abaixo apresenta um figura representando a coleção de pontos:

mpt

Os elementos da coleção podem ser acessados através da propriedade geoms:

for pt in mpt.geoms:
    print(pt.x, pt.y)

5.3.2.6. MultiLineString

Para criar objetos que representam coleções homogeneas de linhas é preciso importar a classe MultiLineString:

from shapely.geometry import MultiLineString

O construtor de uma MultiLineString recebe como argumento uma sequência de linhas:

mline = MultiLineString( [ [ (0, 0), (8, 2), (13, 9) ],
                           [ (21, 11), (30, -1) ] ])

Em um jupyter notebook a expressão abaixo apresenta um figura representando a coleção de linhas:

mline

Uma coleção de linhas possui comprimento:

mline.length

A fronteira de uma coleção de linhas abertas é o conjunto de pontos inicial e final de cada linha, ou seja, objetos \(0\)-dimensional:

mline.boundary

Os elementos das coleção podem ser acessados através da propriedade geoms:

for line in mline.geoms:
    print(line)

5.3.2.7. MultiPolygon

Para criar objetos que representam coleções homogeneas de polígonos é preciso importar a classe MultiPolygon:

from shapely.geometry import MultiPolygon

O construtor de um MultiPolygon recebe como argumento uma sequência de polígonos:

mpoly = MultiPolygon(
         [
           [
               [ (0, 0), (16, 0), (16, 10), (0, 10), (0, 0) ],
               [
                   [ (3, 1), (7, 1), (5, 7), (3, 1) ],
                   [ (8, 1), (12, 1), (10, 9), (8, 1) ]
               ]
           ],
           [
               [ (20, 0), (25, 0), (22, 10), (20, 0) ],
               []
           ]
         ] )

Em um jupyter notebook a expressão abaixo apresenta um figura representando a coleção de polígonos:

mpoly

O mesmo polígono acima pode ser construído de forma mais clara criando os polígonos intermediários e depois criando a coleção:

# Definição do primeiro polígono
shell_1 = LinearRing( [ (0, 0), (16, 0), (16, 10), (0, 10), (0, 0) ] )

hole_11 = LinearRing( [ (3, 1), (7, 1), (5, 7), (3, 1) ] )
hole_12 = LinearRing( [ (8, 1), (12, 1), (10, 9), (8, 1) ] )

poly_1 = Polygon( shell_1, [ hole_11, hole_12 ] )

# Definição do segundo polígono
shell_2 = LinearRing( [ (20, 0), (25, 0), (22, 10), (20, 0) ] )

poly_2 = Polygon(shell_2)

mpoly = MultiPolygon( [ poly_1, poly_2 ] )

mpoly

Uma coleção de polígonos possui comprimento:

mpoly.length

Uma coleção de polígonos possui area:

mpoly.area

A fronteira de uma coleção de polígonos é formada pelos anéis desses polígonos, objetos \(1\)-dimensional:

mpoly.boundary

5.3.3. Relacionamentos Espaciais

Qual o relacionamento espacial entre o ponto de coordenadas (2, 3) e a linha formada pelas coordenadas (1 1, 0 3, 4 3)?

pt = Point(2, 3)


line = LineString( [ (1, 1), (0, 3), (4, 3) ] )

O operador relate pode ser utilizado para determinar a matriz de intersecções, conforme discutido na seção x.x.x:

pt.relate(line)

Podemos também usar esse operador tomando a linha como o objeto da operação e o ponto como argumento:

line.relate(pt)

A linha contém o ponto?

line.contains(pt)

A linha toca o ponto?

line.touches(pt)

A linha cruza o ponto?

line.crosses(pt)

A linha possui alguma interação espacial com o ponto?

line.intersects(pt)

A linha definida anteriormente possui qual relacionamento com o polígono de coordenadas (1 2, 1 4, 3 4, 3 2, 1 2)?

poly = Polygon( [(1, 2), (1, 4), (3, 4), (3, 2), (1, 2)] )

line.relate(poly)

line.intersects(poly)

line.crosses(poly)

A linha (2 1, 2 2, 3 1) toca o polígono anterior?

l2 = LineString( [ (2, 1), (2, 2), (3, 1) ] )

poly.touches(l2)

5.3.4. Operações de Conjunto

p1 = Polygon( [ (1, 2), (1, 4), (3, 4), (3, 2), (1, 2) ] )

p2 = Polygon( [ (2, 1), (2, 3), (4, 3), (4, 1), (2, 1) ] )

g = p1.intersection(p2)

g.wkt

g = p1.union(p2)

g.wkt

g = p1.difference(p2)

g.wkt

g = p1.symmetric_difference(p2)

g.wkt

5.3.5. Formatos

5.3.5.1. OGC WKT (Well-Known Text)

line.wkt

pt.wkt

poly.wkt

g.wkt