ArcPy का उपयोग करके बहुभुज को कई लाइनों के समापन बिंदुओं से जोड़ते हुए बहुभुज बनाना?

10

मैं यह पता लगाने की कोशिश कर रहा हूं कि एक बहुभुज कैसे बनाया जाए जो आर्कगिस में पाइथोन्सस्क्रिप्ट के साथ पॉलीलेन्स के एक सेट वाले आकृति के सभी छोरों को जोड़ता है, मुझे यह करने में परेशानी हो रही है क्योंकि बहुभुज में नोड्स का क्रम महत्वपूर्ण है। मैं हरे रंग की लाइनों से चित्र में ग्रे बहुभुज प्राप्त करना चाहता हूं

arcpy polygon line

— अमांडा
स्रोत

आदेश देने के लिए आपकी लाइनों में कुछ विशेषता है?

— इयान Turton

सबसे पहले, आपको @iant के रूप में परिभाषित आदेश की आवश्यकता है, फिर आपको नियम की आवश्यकता है कि क्या अगले बिंदु पर समापन बिंदु को जोड़ने या इसे किसी अन्य तरीके से करना है

— Matej

3

विफल रहा है कि शायद अंत बिंदुओं पर अल्फा हल के कुछ प्रकार?

— इयान Turton

कुछ हद तक लाइन में उन्हें ऑर्डर देने के लिए विशेषताएँ होती हैं। उनके पास एक आईडी नंबर है, लेकिन राइटब्रांच के ऊपर के उदाहरण के लिए आईडी 1-7, बाएं 15- 21 है और वे आईडी से जुड़े होने के बाद 22-27 हैं

— अमांडा

1

आप एक बहुत करीब से प्राप्त कर सकते हैं) टिन बनाने, लाइनों का उपयोग करके, बी) टिन को त्रिकोण में परिवर्तित करना ग) लाइनों के साथ एक सीमा साझा करने वाले त्रिकोणों का चयन करना। आपके पास शीर्ष पर हटाने के लिए केवल 1 बहुभुज होगा

— FelixIP

11

कदम:

केंद्र बिंदुओं की गणना करें:

उनके यूक्लिडियन न्यूनतम फैले हुए पेड़ का निर्माण किया, इसे भंग कर दिया और बफर की गणना की, कम से कम खंड की लंबाई के बराबर आधा:

बफ़र की सीमा पर खंड अंत बिंदु बनाएं और उनकी श्रृंखला (लाइन के साथ दूरी) की गणना करें (बफ़र के बंद पॉलीलाइन संस्करण):

श्रृंखला क्षेत्र का उपयोग करके आरोही क्रम में अंत बिंदुओं को क्रमबद्ध करें। नीचे दिए गए बिंदु उनके FID द्वारा लेबल किए गए हैं:

बहुभुज बनाएं जो निर्धारित बिंदुओं से हों:

स्क्रिप्ट:

import arcpy, traceback, os, sys,time
from heapq import *
from math import sqrt
import itertools as itt
from collections import defaultdict

try:
    def showPyMessage():
        arcpy.AddMessage(str(time.ctime()) + " - " + message)
    # MST by PRIM's
    def prim( nodes, edges ):
        conn = defaultdict( list )
        for n1,n2,c in edges:
            conn[ n1 ].append( (c, n1, n2) )
            conn[ n2 ].append( (c, n2, n1) )
        mst = []
        used = set( nodes[ 0 ] )
        usable_edges = conn[ nodes[0] ][:]
        heapify( usable_edges )

        while usable_edges:
            cost, n1, n2 = heappop( usable_edges )
            if n2 not in used:
                used.add( n2 )
                mst.append( ( n1, n2, cost ) )

                for e in conn[ n2 ]:
                    if e[ 2 ] not in used:
                        heappush( usable_edges, e )
        return mst        


    mxd = arcpy.mapping.MapDocument("CURRENT")
    SECTIONS=arcpy.mapping.ListLayers(mxd,"SECTION")[0]
    PGONS=arcpy.mapping.ListLayers(mxd,"RESULT")[0]
    d=arcpy.Describe(SECTIONS)
    SR=d.spatialReference

    cPoints,endPoints,lMin=[],[],1000000
    with arcpy.da.SearchCursor(SECTIONS, "Shape@") as cursor:
        # create centre and end points
        for row in cursor:
            feat=row[0]
            l=feat.length
            lMin=min(lMin,feat.length)
            theP=feat.positionAlongLine (l/2).firstPoint
            cPoints.append(theP)
            theP=feat.firstPoint
            endPoints.append(theP)
            theP=feat.lastPoint
            endPoints.append(theP)

        arcpy.AddMessage('Computing minimum spanning tree')
        m=len(cPoints)
        nodes=[str(i) for i in range(m)]
        p=list(itt.combinations(range(m), 2))
        edges=[]
        for f,t in p:
            p1=cPoints[f]
            p2=cPoints[t]
            dX=p2.X-p1.X;dY=p2.Y-p1.Y
            lenV=sqrt(dX*dX+dY*dY)
            edges.append((str(f),str(t),lenV))
        MST=prim(nodes,edges)

        mLine=[]
        for edge in MST:
            p1=cPoints[int(edge[0])]
            p2=cPoints[int(edge[1])]
            mLine.append([p1,p2])
        pLine=arcpy.Polyline(arcpy.Array(mLine),SR)

        # create buffer and compute chainage
        buf=pLine.buffer(lMin/2)
        outLine=buf.boundary()
        chainage=[]
        for p in endPoints:
            measure=outLine.measureOnLine(p)
            chainage.append([measure,p])
        chainage.sort(key=lambda x: x[0])

        # built polygon
        pGon=arcpy.Array()
        for pair in chainage:
            pGon.add(pair[1])
        pGon=arcpy.Polygon(pGon,SR)
        curT = arcpy.da.InsertCursor(PGONS,"SHAPE@")
        curT.insertRow((pGon,))
        del curT
except:
    message = "\n*** PYTHON ERRORS *** "; showPyMessage()
    message = "Python Traceback Info: " + traceback.format_tb(sys.exc_info()[2])[0]; showPyMessage()
    message = "Python Error Info: " +  str(sys.exc_type)+ ": " + str(sys.exc_value) + "\n"; showPyMessage()

मुझे पता है कि यह एक साइकिल है, लेकिन यह मेरी अपनी है और मुझे यह पसंद है

— FelixIP
स्रोत

2

मैं क्यूजीआईएस के लिए इस समाधान को यहां पोस्ट करता हूं क्योंकि यह मुफ्त सॉफ्टवेयर है और इसे लागू करना आसान है। मैंने पॉलीलाइन वेक्टर परत का केवल सही "शाखा" माना; क्योंकि यह अगली छवि में देखा जा सकता है (विशेषताएँ तालिका में 12 सुविधाएँ):

QGIS के पायथन कंसोल में चलने के लिए कोड (एक पंक्ति में अजगर सूची समझ), है:

layer = iface.activeLayer()

features = layer.getFeatures()

features = [feature for feature in features]

n = len(features)

geom = [feature.geometry().asPolyline() for feature in features ]

#multi lines as closed shapes
multi_lines = [[geom[i][0], geom[i][1], geom[i+1][1], geom[i+1][0], geom[i][0]]
               for i in range(n-1)]

#multi polygons
mult_pol = [[] for i in range(n-1)]

for i in range(n-1):
    mult_pol[i].append(multi_lines[i])

#creating a memory layer for multi polygon
crs = layer.crs()
epsg = crs.postgisSrid()

uri = "Polygon?crs=epsg:" + str(epsg) + "&field=id:integer""&index=yes"

mem_layer = QgsVectorLayer(uri,
                           "polygon",
                           "memory")

QgsMapLayerRegistry.instance().addMapLayer(mem_layer)

mem_layer.startEditing()

#Set features
feature = [QgsFeature() for i in range(n-1)]

for i in range(n-1):
    #set geometry
    feature[i].setGeometry(QgsGeometry.fromPolygon(mult_pol[i]))
    #set attributes values
    feature[i].setAttributes([i])
    mem_layer.addFeature(feature[i], True)

#stop editing and save changes
mem_layer.commitChanges()

कोड चलाने के बाद:

यह एक बहुभुज मेमोरी परत (इसकी विशेषताओं तालिका में 11 विशेषताओं के साथ) का उत्पादन किया गया था। यह अच्छी तरह से काम करता है।

— xunilk
स्रोत

1

आप उन समापन बिंदुओं का चयन कर सकते हैं जो बहुभुज में भाग लेंगे, केवल उन बिंदुओं से एक टिन बनाएं। पाली को बहुभुज में बदलें, बहुभुज को भंग करें। इस प्रक्रिया को स्वचालित करने की चाल तय कर रही है जो प्रत्येक बहुभुज में योगदान करने के लिए इंगित करती है। यदि आपके पास मान्य दिशा-निर्देश वाली पंक्तियाँ हैं, और उन पंक्तियों में कुछ सामान्य विशेषता हैं, तो आप निर्यात करने के लिए एक पंक्ति लिख सकते हैं, जिसमें अंतिम कोने को बिंदुओं का उपयोग करते हुए कहा जा सकता है, फिर उन बिंदुओं का चयन करें जिनके पास सामान्य विशेषता मान है।
बेहतर होगा कि अंक निकालें, चयन करें / पढ़ें, एक कर्सर का उपयोग करके x, y मान, एक नया बहुभुज लिखने के लिए x, y मान का उपयोग करें। मैं आपकी पोस्ट में एक संलग्न चित्र नहीं देख सकता, लेकिन यदि बिंदु क्रम मायने रखता है तो एक बार आपके पास एक पायथन सूची में संग्रहीत x, y मान हैं, उन्हें सॉर्ट करें। http://resources.arcgis.com/EN/HELP/MAIN/10.1/index.html#//002z0000001v000000

— GBG
स्रोत

1

@Iant टिप्पणी पर विस्तार करते हुए, आपके स्नैपशॉट के सबसे नज़दीकी ज्यामिति अंतबिंदुओं के अल्फ़ा आकार (अल्फा हल) है। सौभाग्य से कई अच्छी तरह से प्राप्त धागे जीआईएस एसई पर पहले ही जवाब दे चुके हैं। उदाहरण के लिए:

अपनी समस्या को हल करने के लिए, सबसे पहले अंतिम बिंदु निकालने के लिए फ़ीचर टू पॉइंट का उपयोग करें। फिर अवतल पतवार की गणना करने के लिए इस लिंक से अजगर उपकरण का उपयोग करें ।

— फरीद चरगही
स्रोत

आपकी पहली कड़ी टूट गई लगती है।

— PolyGeo