Discussion :

[awalter1]

Bonjour,
Je commence à utiliser le module shapely. Je ne comprends pas la notion de ring malgré le manuel. En particulier l'utilisation de la propriété is_ring me renvoie toujours False :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
polygon=Polygon(((0,0),(0,4),(4,4),(4,0),(0,0)))
print polygon.is_ring
 
False

Merci

[awalter1]

De plus, y a t'il une importance ou pas de définir pour un polygone une suite de coordonnées de points avec coord. dernier point = coord. premier point. Dans les exemples, c'est le cas, mais si on ne le fait pas je ne vois pas l'impact !
Merci

[plxpy]

Bonjour

is_ring est plus un attribut (@property je crois) à utliser sur les instances de LineString (arcs ouverts ou fermés) et LinearRing (arcs fermés). Encore que sur LinearRing, ça n'a guère d'intérêt, étant donné que is_ring est vrai pour un arc qui a les mêmes première et dernière coordonnées, ce qui est une caractéristique des instances de LinearRing.

Je n'avais même pas essayé de l'utiliser sur un Polygon. Et si cela levait une exception, ça ne me dérangerait pas non plus.

Par contre, tu peux le tester sur l'attribut exterior (périmètre extérieur) et chacun, s'il exsitent, des interiors (trous) : ça te retournera True. Mais ça a autant d'intérêt que de l'utiliser sur un LinearRing.

Pour les Polygon, lors de l'appel du constructeur, tu n'es pas obligé d'avoir les mêmes premier et dernier couples de coordonnées (c'est "rajouté", si besoin, automatiquement). C'est écrit quelque part dans la doc

doc constructeur de Polygon

The Polygon constructor takes two positional parameters. The first is an ordered sequence of (x, y[, z]) point tuples and is treated exactly as in the LinearRing case.

et doc constructeur de LinearRing :

The sequence may be explicitly closed by passing identical values in the first and last indices. Otherwise, the sequence will be implicitly closed by copying the first tuple to the last index.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
>>> from shapely.geometry import Polygon
>>> p1=Polygon(((0,0),(0,1),(1,1),(1,0)))
>>> p2=Polygon(((0,0),(0,1),(1,1),(1,0),(0,0)))
>>> p1.wkt
'POLYGON ((0.0000000000000000 0.0000000000000000, 0.0000000000000000 1.0000000000000000, 1.0000000000000000 1.0000000000000000, 1.0000000000000000 0.0000000000000000, 0.0000000000000000 0.0000000000000000))'
>>> p2.wkt
'POLYGON ((0.0000000000000000 0.0000000000000000, 0.0000000000000000 1.0000000000000000, 1.0000000000000000 1.0000000000000000, 1.0000000000000000 0.0000000000000000, 0.0000000000000000 0.0000000000000000))'
>>>
>>> p1.equals(p2)
True
>>> p1.exterior.is_ring
True

[awalter1]

Merci de ces infos.
A présent je veux faire quelques chose de relativement simple ; tester l'intersection de 2 polygones, pourtant je tourne en rond.
J'ai testé les methodes intersects(), intersection(), crosses(), mais je n'ai pas les résultats espérés. Je pense que cela vient du fait que certains polygones ont des frontières communes, ce qui est normal pour moi mais doit être vu comme des polygones disjoints : ce n'est pas la logique de shapely.
Comment puis je savoir si 2 polygones se recouvrent (sans tenir compte des segments communs) ?
Dans le cas ou je fais P1.intersection(P2) pour des polygones qui ont des segments communs, je peux tester si le résultat est une polyline et j'en déduirai qu'il n'y a pas overlap, mais ce n'est pas très efficace.
Merci

[plxpy]

mais ce n'est pas très efficace.

pourquoi ? Tester la classe de l'objet retourné par la méthode intersection est une bonne idée. Ce que tu veux, c'est une intersection qui soit de la classe Polygon ou MultiPolygon (ou qui ait une partie qui soit dans ce cas là: attention aux résultats/intersections de type GeometryCollection !)

Et si c'est au niveau des performances que tu trouves que ce n'est pas très efficace, c'est peut-être que tu as de nombreux polygones et que tu testes tous les couples possibles, non ?

[plxpy]

En fait, si tu veux déterminer les polygones qui se "recouvrent" (qui ont une intersection surfacique et non pas linéaire), le mieux est encore d'utiliser les prédicats intersects et touches.

Pour avoir une intersection surfacique, les polygones doivent s'intersecter mais ne pas se toucher :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> from shapely.geometry import Polygon
>>> p1=Polygon(((0,0),(0,1),(1,1),(1,0)))
>>> p2=Polygon(((1,0),(1,1),(2,1),(2,0)))
>>>
>>> p1.intersects(p2)
True
>>> p1.touches(p2)
True
>>> 
>>> p3=Polygon(((0.5,0),(0.5,1),(1.5,1),(1.5,0)))
>>> p1.intersects(p3)
True
>>> p1.touches(p3)
False

La "logique" Shapely est héritée de la bibliothèque C/C++ GEOS, portage de JTS (Java Topology Suite, voir les spécifications techniques), elle-même calquée sur les standards OGC. Elle peut parfois sembler déroutante au premier abord mais, en fait, c'est la façon de traiter les cas "finauds" (tordus ?) qu'on rencontre plus souvent qu'on ne le pense (et je sais de quoi je parle !)