QGIS में हेक्सागोनल ग्रिड के लिए सड़क नेटवर्क को कैसे स्नैप करें?

13

मैं एक हेक्सागोनल ग्रिड के लिए सड़क नेटवर्क को स्नैप करने के लिए QGIS 2.14 का उपयोग करने की कोशिश कर रहा हूं, लेकिन मुझे अजीब कलाकृतियां मिल रही हैं।

मैंने MMQGIS के साथ एक हेक्स ग्रिड बनाया है , सेल लगभग 20 x 23 मीटर हैं। मैंने सड़क नेटवर्क को 1 मी से बफ़र कर दिया है और इसे घनीभूत कर दिया है, इसलिए हर कुछ मीटर पर एक नोड है। आप देख सकते हैं कि मैं नीचे क्या हासिल करने की कोशिश कर रहा हूं। जैसा कि आप देख सकते हैं, मैं इसे कुछ मामलों में काम करने के लिए प्राप्त कर सकता हूं: -

नीली सघन सड़क है (एक बफर लाइन)
लाल 'हेक्सिफाइड' संस्करण है - यह वही है जो मैं खोजना चाहता हूं
ग्रे हेक्स ग्रिड है

फिर मैंने निकटतम हेक्सागोन कोने में नोड्स को स्नैप करने के लिए नई स्नैप ज्यामिति सुविधा का उपयोग किया । परिणाम आशाजनक हैं, लेकिन कुछ किनारे मामले प्रतीत होते हैं जहां रेखा षट्भुज (या इसके कुछ भाग) को भरने के लिए फैलती है: -

बफर का कारण यह है कि स्नैप जियोमेट्री आपको एक ऐसी परत को स्नैप नहीं करती है जिसकी ज्यामिति अलग है। उदाहरण के लिए, आप किसी POINT लेयर पर बिंदुओं पर LINE लेयर पर नोड्स स्नैप नहीं कर सकते हैं)। ऐसा लगता है कि पोलीगॉन में सबसे ज्यादा स्निपिंग पॉलीगॉन है।

मुझे संदेह है कि सड़क का विस्तार तब होता है जब बफर रोड लाइन के एक तरफ हेक्स सेल के एक तरफ कूदता है, और दूसरी तरफ हेक्स सेल के दूसरी तरफ कूदता है। मेरे उदाहरण में, एक तीव्र कोण पर पश्चिम-पूर्व को पार करने वाली सड़कें सबसे खराब लगती हैं।

चीजें जो मैंने कोशिश की हैं, सफलता के बिना: -

एक छोटी राशि से सड़क नेटवर्क को बफर करना, इसलिए यह बहुभुज बना रहता है लेकिन बहुत पतला है।
हेक्स कोशिकाओं को सघन करना (इसलिए किनारों पर नोड्स हैं, न कि कोनों पर)
अधिकतम तड़कने की दूरी को अलग करना (इसका सबसे बड़ा प्रभाव है, लेकिन मुझे एक आदर्श मूल्य नहीं मिल सकता है)
LINE लेयर्स का उपयोग करना, POLYGONs का नहीं

मुझे लगता है कि अगर मैं सिर्फ LINE लेयर का उपयोग करने के लिए बदलूं, यह थोड़ी देर के लिए काम करता है, तो क्रैश हो जाता है। यह अपने काम को बचाने के लिए लगता है क्योंकि यह जाता है - कुछ लाइनों को आंशिक रूप से संसाधित किया गया है।

क्या किसी को किसी लाइन पर पॉइंट्स को स्नैप करने का कोई अन्य तरीका किसी अन्य लाइन / पॉलीगॉन लेयर पर निकटतम बिंदु पर पता है, आदर्श रूप से पोस्टग्रेज / पोस्टगिस का उपयोग करने की आवश्यकता के बिना (हालांकि पोस्टगिस के साथ एक समाधान भी स्वागत होगा)?

संपादित करें

जो कोई भी जाना चाहता है, उसके लिए मैंने ड्रॉपबॉक्स पर एक स्टार्टर QGIS प्रोजेक्ट यहां रखा है । इसमें हेक्स ग्रिड और डेंसिफाइड लाइनों की परतें शामिल हैं। (सड़क नेटवर्क OSM से है, इसलिए अगर आप सड़कों को तेज करने के लिए मूल प्राप्त करना चाहते हैं, तो QuickOSM का उपयोग करके डाउनलोड किया जा सकता है)।

ध्यान दें कि यह OSGB (epsg: 27700) में है, जो मीटर के लिए इकाइयों के साथ यूके के लिए एक स्थानीय UTM है।

— स्टीवन के
स्रोत

3

क्या आप एक नमूना डेटासेट साझा कर सकते हैं? मैं इसे एक कोशिश देना चाहूंगा, लेकिन स्क्रैच से नमूना डेटा बनाने की प्रक्रिया पर नहीं जाना चाहता।

— जर्मेन कैरिलो

@ जर्मेनक्रिल्लो - धन्यवाद। मैंने प्रश्न के लिए एक नमूना परियोजना का लिंक जोड़ा है।

— स्टीवन काई

14

मेरे समाधान में एक PyQGIS स्क्रिप्ट शामिल है जो तड़क-भड़क से जुड़े वर्कफ़्लो से अधिक तेज़ और प्रभावी है (मैंने इसे भी आज़माया)। अपने एल्गोरिथ्म का उपयोग करके मैंने ये परिणाम प्राप्त किए हैं:

आप QGIS (QGIS पायथन कंसोल में) से निम्न कोड स्निपेट्स अनुक्रम में चला सकते हैं। अंत में आपको क्यूजीआईएस में लोड किए गए मार्गों के साथ एक मेमोरी लेयर मिलती है।

एकमात्र शर्त मल्टीपार्ट रोड शेपफाइल बनाना है (उपयोग Processing->Singleparts to multipart, मैंने पैरामीटर के fictitiuosरूप में फ़ील्ड का उपयोग किया है Unique ID field)। यह हमें roads_multipart.shpसिंगल फीचर वाला फाइल देगा ।

यहाँ एल्गोरिथम समझाया गया है:

निकटतम हेक्सागोन पक्ष प्राप्त करें जहां मार्ग पार करते हैं। प्रत्येक षट्भुज के लिए हम प्रत्येक जोड़े को पड़ोसी कोने और संबंधित केन्द्रक के बीच 6 त्रिकोण बनाते हैं। यदि कोई सड़क एक त्रिकोण को काटती है, तो हेक्सागोन द्वारा साझा किए गए खंड और त्रिकोण को अंतिम तड़क मार्ग में जोड़ा जाता है। यह पूरे एल्गोरिथ्म का सबसे भारी हिस्सा है, मेरी मशीन पर चलने में 35 सेकंड लगते हैं। पहले दो पंक्तियों में 2 शेपफाइल पथ हैं, आपको उन्हें अपने स्वयं के फ़ाइल पथों को फिट करने के लिए समायोजित करना चाहिए।

hexgrid = QgsVectorLayer("/docs/borrar/hex_grid_question/layers/normal-hexgrid.shp", "hexgrid", "ogr")
roads = QgsVectorLayer("/docs/borrar/hex_grid_question/layers/roads_multipart.shp", "roads", "ogr")  # Must be multipart!

roadFeat = roads.getFeatures().next() # We just have 1 geometry
road = roadFeat.geometry() 
indicesHexSides = ((0,1), (1,2), (2,3), (3,4), (4,5), (5,0))

epsilon = 0.01
# Function to compare whether 2 segments are equal (even if inverted)
def isSegmentAlreadySaved(v1, v2):
    for segment in listSegments:        
        p1 = QgsPoint(segment[0][0], segment[0][1])
        p2 = QgsPoint(segment[1][0], segment[1][1])
        if v1.compare(p1, epsilon) and v2.compare(p2, epsilon) \
            or v1.compare(p2, epsilon) and v2.compare(p1, epsilon):
            return True
    return False

# Let's find the nearest sides of hexagons where routes cross
listSegments = []
for hexFeat in hexgrid.getFeatures():
    hex = hexFeat.geometry()
    if hex.intersects( road ):
        for side in indicesHexSides:
            triangle = QgsGeometry.fromPolyline([hex.centroid().asPoint(), hex.vertexAt(side[0]), hex.vertexAt(side[1])])
            if triangle.intersects( road ):
                # Only append new lines, we don't want duplicates!!!
                if not isSegmentAlreadySaved(hex.vertexAt(side[0]), hex.vertexAt(side[1])): 
                    listSegments.append( [[hex.vertexAt(side[0]).x(), hex.vertexAt(side[0]).y()], [hex.vertexAt(side[1]).x(),hex.vertexAt(side[1]).y()]] )

पायथन सूचियों, टुपल्स और शब्दकोशों का उपयोग करके डिस्कनेक्ट (या 'ओपन') सेगमेंट से छुटकारा पाएं । इस बिंदु पर, कुछ डिस्कनेक्ट किए गए सेगमेंट बचे हुए हैं, यानी ऐसे सेगमेंट जिनमें एक वर्टेक्स डिस्कनेक्ट हो गया है, लेकिन दूसरा कम से कम अन्य 2 सेगमेंट से जुड़ा हुआ है (अगले आंकड़े में लाल सेगमेंट देखें)। हमें उनसे छुटकारा पाने की जरूरत है।
```
# Let's remove disconnected/open segments
lstVertices = [tuple(point) for segment in listSegments for point in segment]
dictConnectionsPerVertex = dict((tuple(x),lstVertices.count(x)-1) for x in set(lstVertices))

# A vertex is not connected and the other one is connected to 2 segments
def segmentIsOpen(segment):
    return dictConnectionsPerVertex[tuple(segment[0])] == 0 and dictConnectionsPerVertex[tuple(segment[1])] >= 2 \
        or dictConnectionsPerVertex[tuple(segment[1])] == 0 and dictConnectionsPerVertex[tuple(segment[0])] >= 2

# Remove open segments
segmentsToDelete = [segment for segment in listSegments if segmentIsOpen(segment)]        
for toBeDeleted in segmentsToDelete:
    listSegments.remove( toBeDeleted )
```

अब हम निर्देशांक की सूची से एक वेक्टर लेयर बना सकते हैं और इसे QGIS मैप में लोड कर सकते हैं :

# Create a memory layer and load it to QGIS map canvas
vl = QgsVectorLayer("LineString", "Snapped Routes", "memory")
pr = vl.dataProvider()
features = []
for segment in listSegments:
    fet = QgsFeature()
    fet.setGeometry( QgsGeometry.fromPolyline( [QgsPoint(segment[0][0], segment[0][1]), QgsPoint(segment[1][0], segment[1][1])] ) )
    features.append(fet)

pr.addFeatures( features )
vl.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(vl)

परिणाम का एक और हिस्सा:

क्या आपको तले हुए मार्गों में विशेषताओं की आवश्यकता है, हम तेजी से चौराहों (जैसे /gis//a/130440/4972 ) का मूल्यांकन करने के लिए एक स्थानिक सूचकांक का उपयोग कर सकते हैं , लेकिन यह एक और कहानी है।

उम्मीद है की यह मदद करेगा!

— जर्मेन कैरिलो
स्रोत

1

धन्यवाद, यह पूरी तरह से काम करता है! इसे अजगर कंसोल में चिपकाने में समस्याएं थीं ... मैंने इसे क्यूजीस पायथन संपादक में एक .py फ़ाइल के रूप में सहेजा, और यह वहां से ठीक चला। मल्टीपार्ट कदम विशेषताओं को हटा देता है, लेकिन एक बफर / स्थानिक जुड़ाव इसे ठीक कर देगा!

— स्टीवन केय

1

महान! खुशी है कि अंत में आपके सामने जो समस्या थी, उसे हल कर दिया। मुझे यह जानने में दिलचस्पी है कि आपके द्वारा उपयोग किए जा रहे उपयोग के मामले में क्या है। क्या आपको लगता है कि हम इसका लाभ उठाने के लिए QGIS प्लगइन या शायद एक स्क्रिप्ट जो प्रसंस्करण स्क्रिप्ट में शामिल है?

— जर्मेन कैरिलो

1

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

— स्टीवन Kay

1

स्क्रिप्ट के पीछे का विचार त्रिकोण, वर्गों, पेंटागन, हेक्सागोन्स और इतने पर ग्रिड पर काम करेगा।

— जर्मेन कैरिलो

6

मैंने इसे आर्कजीआईएस में किया था, निश्चित रूप से क्यूजीआईएस का उपयोग करके लागू किया जा सकता है या बस ज्यामितीय पढ़ने में सक्षम पैकेज के साथ अजगर। सुनिश्चित करें कि सड़कें नेटवर्क का प्रतिनिधित्व करती हैं, यानी केवल एक दूसरे को सिरों पर काटती हैं। आप ओएसएम के साथ काम कर रहे हैं, मुझे लगता है कि यह मामला है।

निकटता वाले बहुभुजों को लाइनों में परिवर्तित करें और उन्हें योजनाबद्ध करें, इसलिए वे एक ज्यामितीय नेटवर्क भी बन जाते हैं।
उनके सिरों पर जगह बिंदु - वोरोनोई अंक:
नियमित रूप से 5 मीटर के अंतराल पर सड़क पर प्वाइंट रखें, सुनिश्चित करें कि नेटवर्क सड़कों का अच्छा अद्वितीय नाम है:

प्रत्येक रोड पॉइंट के लिए निकटतम वोरोनोई पॉइंट के निर्देशांक खोजें:
उसी क्रम में निकटतम बिंदुओं को जोड़कर "सड़कें" बनाएं:

यदि आप इसे नहीं देखना चाहते हैं:

Voronoi तर्ज पर श्रृंखला बिंदुओं का उपयोग करने का प्रयास न करें। मुझे डर है कि यह केवल बदतर बना देगा। इस प्रकार आपका एकमात्र विकल्प वोरोनोई लाइनों से नेटवर्क बना रहा है और सड़क के अंत बिंदुओं के बीच मार्ग खोजता है, यह कोई बड़ी बात नहीं है

— FelixIP
स्रोत

यह बहुत अच्छा है, धन्यवाद! आप वोरोनोई लाइनों का उपयोग करने का उल्लेख करते हैं, उस से भी परिचित नहीं हैं (अंकों से वोरोनिश, मैं समझ सकता हूं)। क्या आपका मतलब है कि प्रत्येक रेखा उस रेखा के सबसे करीब सभी बिंदुओं के बहुभुज से घिरी है? (मैं QGIS में ऐसा करने के तरीके से अवगत नहीं हूं)। या क्या आप बिंदुओं के आधार पर एक सामान्य वोरोनोई जाल से सीमा रेखाओं का मतलब रखते हैं?

— स्टीवन केई

निकटता बहुभुज की सीमा रेखाएँ। Btw मैं बहुत जल्दी बंद कर दिया। कार्य को पूरा करने के लिए यह 1 परिणाम को शीर्ष पर विभाजित करने के लिए पर्याप्त है, मध्य बिंदु पर बिंदु को दोहराएं और प्रक्रिया को दोहराएं

— फेलिक्सिप

4

मुझे लगता है कि आप एक QGIS विधि के लिए पूछ रहे हैं, लेकिन मेरे साथ एक आर्कषक उत्तर के लिए है:

roads = 'clipped roads' # roads layer
hexgrid = 'normal-hexgrid' # hex grid layer
sr = arcpy.Describe('roads').spatialReference # spatial reference
outlines = [] # final output lines
points = [] # participating grid vertices
vert_dict = {} # vertex dictionary
hex_dict = {} # grid dictionary
with arcpy.da.SearchCursor(roads,["SHAPE@","OID@"], spatial_reference=sr) as r_cursor: # loop through roads
    for r_row in r_cursor:
        with arcpy.da.SearchCursor(hexgrid,["SHAPE@","OID@"], spatial_reference=sr) as h_cursor: # loop through hex grid
            for h_row in h_cursor:
                if not r_row[0].disjoint(h_row[0]): # check if the shapes overlap
                    hex_verts = []
                    for part in h_row[0]:
                        for pnt in part:
                            hex_verts.append(pnt) # add grid vertices to list
                    int_pts = r_row[0].intersect(h_row[0],1) # find all intersection points between road and grid
                    hex_bnd = h_row[0].boundary() # convert grid to line
                    hex_dict[h_row[1]] = hex_bnd # add grid geometry to dictionary
                    for int_pt in int_pts: # loop through intersection points
                        near_dist = 1000 # arbitrary large number
                        int_pt = arcpy.PointGeometry(int_pt,sr)
                        for hex_vert in hex_verts: # loop through hex vertices
                            if int_pt.distanceTo(hex_vert) < near_dist: # find shortest distance between intersection point and grid vertex
                                near_vert = hex_vert # remember geometry
                                near_dist = int_pt.distanceTo(hex_vert) # remember distance
                        vert_dict.setdefault(h_row[1],[]).append(arcpy.PointGeometry(near_vert,sr)) # store geometry in dictionary
                        points.append(arcpy.PointGeometry(near_vert,sr)) # add to points list
for k,v in vert_dict.iteritems(): # loop through participating vertices
    if len(v) < 2: # skip if there was only one vertex
        continue
    hex = hex_dict[k] # get hex grid geometry
    best_path = hex # longest line possible is hex grid boundary
    for part in hex:
        for int_vert in v: # loop through participating vertices
            for i,pnt in enumerate(part): # loop through hex grid vertices
                if pnt.equals(int_vert): # find vertex index on hex grid corresponding to current point
                    start_i = i
                    if start_i == 6:
                        start_i = 0
                    for dir in [[0,6,1],[5,-1,-1]]: # going to loop once clockwise, once counter-clockwise
                        past_pts = 0 # keep track of number of passed participating vertices
                        cur_line_arr = arcpy.Array() # polyline coordinate holder
                        cur_line_arr.add(part[start_i]) # add starting vertex to growing polyline
                        for j in range(dir[0],dir[1],dir[2]): # loop through hex grid vertices
                            if past_pts < len(v): # only make polyline until all participating vertices have been visited
                                if dir[2] == 1: # hex grid vertex index bookkeeping
                                    if start_i + j < 6:
                                        index = start_i + j
                                    else:
                                        index = (start_i - 6) + j
                                else:
                                    index = j - (5 - start_i)
                                    if index < 0:
                                        index += 6
                                cur_line_arr.add(part[index]) # add current vertex to growing polyline
                                for cur_pnt in v:
                                    if part[index].equals(cur_pnt): # check if the current vertex is a participating vertex
                                        past_pts += 1 # add to counter
                        if cur_line_arr.count > 1:
                            cur_line = arcpy.Polyline(cur_line_arr,sr)
                            if cur_line.length < best_path.length: # see if current polyline is shorter than any previous candidate
                                best_path = cur_line # if so, store polyline
    outlines.append(best_path) # add best polyline to list
arcpy.CopyFeatures_management(outlines, r'in_memory\outlines') # write list
arcpy.CopyFeatures_management(points, r'in_memory\mypoints') # write points, if you want

टिप्पणियाँ:

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

— फ्लोएम
स्रोत

इसके लिए धन्यवाद, बहुत सराहना की। यह वास्तव में मेरे द्वारा देखे जाने वाले प्रभाव को दर्शाता है । मैत्रीपूर्ण टिप्पणियों का मतलब है कि मैं क्या कर रहा हूँ का सार प्राप्त कर सकते हैं, भले ही मैं कोड नहीं चला सकता। हालांकि यह चापलूस है, मुझे यकीन है कि यह pyqgis में उल्लेखनीय होगा। यहाँ एल्गोरिथ्म के विचार दिलचस्प हैं (विशेषकर घड़ी की सूई और एंटीलॉकवाइज़ दोनों को एक-एक राउंड में देख रहे हैं, और सबसे छोटा रास्ता चुन रहे हैं)

— स्टीवन केय

2

यदि आप सड़क रेखा को उन खंडों में विभाजित करना चाहते थे, जहाँ प्रत्येक खंड पूरी तरह से षट्भुज द्वारा समाहित था, तो आपका निर्णय जिस पर उपयोग करने के लिए षट्भुज रेखा खंड होंगे, यह विभाजित सड़क खंड के केंद्रक से प्रत्येक षट्भुज पक्ष के मध्य बिंदु की दूरी आधे से कम थी या नहीं षट्भुज का व्यास (या एक वृत्त की त्रिज्या से कम जो षट्भुज के अंदर फिट होता है)।

इस प्रकार, यदि आप (एक समय में एक खंड) षट्भुज लाइन खंडों का चयन करें (जहां प्रत्येक खंड षट्भुज का एक पक्ष है) जो षट्भुज की त्रिज्या की दूरी के भीतर हैं, तो आप उन रेखाओं को कॉपी कर सकते हैं और उन पर विलय कर सकते हैं जो भी अद्वितीय पहचानकर्ता आप अपने सड़क डेटासेट के लिए उपयोग करते हैं।

यदि आपको विशिष्ट पहचानकर्ता पर विलय करने में समस्या है, तो आप बफर को लागू कर सकते हैं और अपने सड़क डेटासेट की विशेषताओं को लागू करने के लिए केवल उन खंडों पर स्थान चुन सकते हैं; इस तरह आपको एक बड़े बफर के साथ झूठे मेल बनाने के बारे में चिंता करने की ज़रूरत नहीं होगी।

स्नैप टूल के साथ समस्या यह है कि यह स्नैप को अंधाधुंध तरीके से इंगित करता है; उस सही सहिष्णुता का उपयोग करना मुश्किल है। इस पद्धति के साथ आप सही ढंग से पहचान कर पाएंगे कि कौन सी षट्भुज रेखा खंडों का उपयोग करना है, फिर अपने सड़क डेटा की ज्यामिति (या ज्यामिति को अलग डेटासेट में सम्मिलित करना) की जगह ले लें।

इसके अलावा, यदि आपके पास अभी भी लाइन सेगमेंट के साथ समस्या है जो षट्भुज के एक तरफ से दूसरी तरफ कूदती है, तो आप पंक्ति को खंडों से खंडों में विभाजित कर सकते हैं, प्रत्येक पंक्ति की लंबाई की गणना कर सकते हैं, फिर किसी भी रेखा खंड को हटा सकते हैं जो इससे बड़ा है षट्भुज के एक तरफ की औसत लंबाई।

— crld
स्रोत

1

क्यूगिस 3.0 में ज्यामिति स्नैपर को फिर से काम किया गया है और अब विभिन्न ज्यामिति प्रकारों के बीच तड़कने की अनुमति देता है। इसमें बहुत सारे सुधार भी हैं। 3.0 से पहले आधिकारिक रूप से जारी किए गए बेहतर स्नैपर तक पहुंचने के लिए आप "दैनिक स्नैपशॉट" संस्करण का प्रयास कर सकते हैं।

— ndawson
स्रोत