पायथन में दो पॉलीगॉन इंटर्सेक्ट होने पर ढूँढना?

Question

मैं एक एल्गोरिथ्म, एक उच्च स्तरीय समाधान, या यहां तक ​​कि एक पुस्तकालय की तलाश कर रहा हूं जो मुझे यह निर्धारित करने में मदद कर सकता है कि पायथन में दो पॉलीगॉन इंटरसेक्ट करते हैं या नहीं।

मेरे पास दो अलग-अलग सरणियों में दो बहुभुज (ये बिना किसी छेद के एकल भाग बहुभुज हैं)। बहुभुज 2D हैं (यानी सिर्फ X और Y निर्देशांक)

मैं एक फंक्शन बनाना चाहूंगा जो एक बूलियन को यह संकेत दे कि क्या ये दो बहुभुज प्रतिच्छेद करेंगे।

कृपया ध्यान दें कि मैं इसका उपयोग नहीं कर सकता arcpy, या इसमें कोई arcgisघटक नहीं।

क्या आप ऐसा करने के लिए एक एल्गोरिथ्म या पुस्तकालय का सुझाव दे सकते हैं?

Answer 1

आप की कोशिश कर सकते सुडौल ।

वे स्थानिक संबंधों का वर्णन करते हैं और यह खिड़कियों पर काम करता है

स्थानिक डेटा मॉडल ज्यामितीय वस्तुओं के बीच प्राकृतिक भाषा के रिश्तों के एक समूह के साथ होता है - जिसमें सम्‍मिलित, अवक्षेप, अतिवृष्टि, स्पर्श आदि होते हैं - और उनके घटक बिंदु सेटों के आपसी चौराहों के 3x3 मैट्रिक्स का उपयोग करके उन्हें समझने के लिए एक सैद्धांतिक रूपरेखा।

निम्नलिखित कोड दिखाता है कि आप किस तरह से चौराहे के लिए परीक्षण कर सकते हैं:

from shapely.geometry import Polygon
p1 = Polygon([(0,0), (1,1), (1,0)])
p2 = Polygon([(0,1), (1,0), (1,1)])
print(p1.intersects(p2))

Answer 2

आप उसके लिए GDAL / OGR पायथन बाइंडिंग का उपयोग कर सकते हैं ।

from osgeo import ogr

wkt1 = "POLYGON ((1208064.271243039 624154.6783778917, 1208064.271243039 601260.9785661874, 1231345.9998651114 601260.9785661874, 1231345.9998651114 624154.6783778917, 1208064.271243039 624154.6783778917))"
wkt2 = "POLYGON ((1199915.6662253144 633079.3410163528, 1199915.6662253144 614453.958118695, 1219317.1067437078 614453.958118695, 1219317.1067437078 633079.3410163528, 1199915.6662253144 633079.3410163528)))"

poly1 = ogr.CreateGeometryFromWkt(wkt1)
poly2 = ogr.CreateGeometryFromWkt(wkt2)

intersection = poly1.Intersection(poly2)

print intersection.ExportToWkt()

Noneअगर वे अंतर नहीं करते हैं तो यह वापस आ जाता है। यदि वे इसे प्रतिच्छेद करते हैं तो यह रिटर्न करता है कि ज्यामिति दोनों प्रतिच्छेदन थे।

इसके अलावा आप GDAL / OGR रसोई की किताब में आगे infos पा सकते हैं ।

Comments

मैं इसका उपयोग करना पसंद करूंगा, लेकिन मैं विंडोज़ पर हूं, और दोनों प्रणालियों पर मैंने कोशिश की है, मुझे काम करने के लिए अजगर बाँध नहीं मिल सकता है। मैं इस पोस्ट में वर्णित समस्या में भागता हूं

— Devdatta Tengshe

बस इस पर मामला किसी और stumbles में, यह (और ArcGIS भीतर कम नहीं) Windows में अजगर के साथ GDAL / OGR उपयोग करना संभव है: gis.stackexchange.com/questions/74524/...

— ईविल प्रतिभाशाली

आप चौराहे भी लिख सकते हैं = poly1.Intersect (पॉली 2) --- चौराहे का मूल्य TRUE या FALSE होगा यदि पॉलीगॉन प्रतिच्छेद के आधार पर

— अधिकतम

Answer 3

यदि आप जानते हैं या आर सीखने में रुचि रखते हैं तो इसके कुछ उपयोगी स्थानिक पैकेज हैं। http://cran.r-project.org/web/views/Spatial.html आर (RPF) के साथ बातचीत करने के लिए पायथन मॉड्यूल है

Answer 4

मुझे पता है कि यह एक पुराना सवाल है, लेकिन मैंने अवतल और उत्तल बहुभुजों के बीच टकराव से निपटने के लिए एक अजगर पुस्तकालय लिखा है, साथ ही साथ मंडलियां भी।

यह प्रयोग करने के लिए बहुत आसान है, यहाँ आप जाओ!

उदाहरण:

from collision import *
from collision import Vector as v

p0 = Concave_Poly(v(0,0), [v(-80,0), v(-20,20), v(0,80), v(20,20), v(80,0),  v(20,-20), v(0,-80), v(-20,-20)])
p1 = Concave_Poly(v(20,20), [v(-80,0), v(-20,20), v(0,80), v(20,20), v(80,0),  v(20,-20), v(0,-80), v(-20,-20)])

print(collide(p0,p1))

आप यह भी एक उत्पन्न कर सकते हैं, जिसमें शामिल हैं:

overlap (how much they overlap)
overlap vector (when subtracted from second shapes position, the shapes will no longer be colliding)
overlap vector normalized (vector direction of collision)
a in b (whether the first shape is fully inside the second)
b in a (whether the second shape is fully inside the first)

https://github.com/QwekoDev/collision

Answer 5

यदि आप उस स्तर को जानना चाहते हैं जो आप इसका उपयोग कर सकते हैं। एक तर्क के रूप में आप बहुभुज की एक सूची दे सकते हैं। और वापसी मूल्य के रूप में आपको स्तरों की एक सूची मिलती है। स्तरों की सूची में बहुभुज हैं।

from shapely.geometry import Point
from shapely.geometry.polygon import Polygon
def isPolygonInPolygon(poly1,poly2):
    poly2 = Polygon(poly2)
    for poi in poly1:
        poi = Point(poi)
        if(poly2.contains(poi)):
            return True

def polygonTransformHierarchy(polygon_list):
    polygon_list_hierarchy = []
    for polygon1 in polygon_list:
        level = 0
        for polygon2 in polygon_list:
            if(isPolygonInPolygon(polygon1, polygon2)):
                level += 1
        if(level > len(polygon_list_hierarchy)-1):
            dif = (level+1)- len(polygon_list_hierarchy)
            for _ in range(dif):
                polygon_list_hierarchy.append([])   
        polygon_list_hierarchy[level].append(polygon1)
    return polygon_list_hierarchy