समान लाइनों और अद्यतन परतों की तुलना करें

Question

यहां गलियों के प्रतिनिधित्व के साथ दो परतें हैं और विचार यह है: हम सबसे हाल की परत (लाल रेखा के साथ) को अपडेट करना चाहते हैं, जिसमें कुछ डेटा एक दूसरे (हल्के नीले) में संग्रहीत हैं, लेकिन ये परतें हैं भौगोलिक स्थिति के समान जो नक्शे में जगह के आधार पर बहुत करीब और थोड़ा अधिक दूर हो सकती है और केवल एक विशेषता मामलों में मेल खाती है कि एक लाइन दूसरे में समान है (कोडलॉग x कोडलॉग 5)।

उदाहरण के लिए: छवि के बीच में, दोनों परतों में एक वर्ग है, लेकिन मैं नीले रंग को पहचानने के लिए नक्शे में कैसे करूं कि हरे रंग के समान है और हाल की परत को अपडेट करें?

मैं यह कैसे कर सकता हूं? वहाँ किसी भी प्लगइन या उपकरण है कि इसके साथ मदद करता है?

Comments

आप नीली परत की विशेषताओं के साथ या नीली परत से अतिरिक्त सुविधाओं के साथ लाल परत को अपडेट करना चाहते हैं?

— dhh126

गुण। स्थिति: लाल परत में कॉलम (ए, बी, सी, डी) और नीला एक कॉलम होता है (डी, ई, एफ)। मैं लाल परत के कॉलम (e, f) को दूसरी परत से जोड़ना चाहता हूं और इसके परिणाम जो मेल खाते हैं।

— झोटन ओलिवेरा

एक कंफ़्लेशन प्लगइन के लिए यहाँ कुछ प्रलेखन है । यकीन नहीं होता कि विकास पूरा हो गया है।

— Barbarossa

क्या आपने कूदने की कोशिश की है?

— राडौक्सू

लेकिन ब्लर लाइन का कॉलम "d" और रेड का "d" एक यूनिक कॉमन आईडी हैं? उनमें क्या है?

— सर्जियो

Answer 1

यह एक महान प्रश्न है, मुझे हाल ही में कुछ ऐसा ही करना था लेकिन बहुत छोटे डेटासेट के साथ, इसलिए मैं कुछ अतिरिक्त दृश्य गुणवत्ता जाँच के साथ एक साधारण चौराहे का उपयोग करने में सक्षम था और यह ठीक था।

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

1. अच्छा ज्यामिति सेट लें (जहां आप विशेषताओं को समाप्त करना चाहते हैं) और इसका बफर बनाएं *

2. बफर सुविधाओं में से प्रत्येक के माध्यम से पुनरावृति:

   2 ए। सुविधा के सामान्य अभिविन्यास की गणना करें (max_y - min_y / max_x - min_x या ऐसा कुछ)

   2 बी। इस सिंगल फ़ीचर का उपयोग करके अन्य लेयर पर स्थान क्वेरी द्वारा चयन करें

   3. आपके पास एक से अधिक फ़ीचर होंगे जो स्थान क्वेरी द्वारा चयन से मेल खाते हैं, इसलिए इन चयनित सुविधाओं के माध्यम से पुनरावृति करें और प्रत्येक के अभिविन्यास की गणना करें

   4. जो भी सुविधा से विशेषताएँ प्राप्त करें, वह बाइनरी सुविधा के सबसे करीब है।

* मैं एक बहुत छोटी दूरी (एक नक्शा इकाई या कुछ) के साथ शुरू करूंगा और फिर इस प्रक्रिया को बढ़ती दूरी के साथ चलाऊंगा, किसी भी विशेषताओं को अधिलेखित न करने के लिए सावधान रहें जो आपने पहले ही स्थानांतरित कर चुके हैं।

** आप वास्तव में बफर सुविधाओं को बनाने से बच सकते हैं, और बस इसमें बफर दूरी के साथ स्थान क्वेरी का चयन करें। मैं QGIS से बहुत परिचित नहीं हूं, लेकिन मुझे यकीन है कि आप ऐसा कर पाएंगे।

इसका कोई तरीका नहीं है कि यह आपकी सभी विशेषताओं के लिए पूरी तरह से काम करेगा, लेकिन यह एक शुरुआत है, और फिर यह स्थानांतरण की जाँच और पूर्ण करने के लिए एक अच्छी QA / QC रणनीति विकसित करने के लिए नीचे आता है।

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

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

EDIT 2 उफ़, क्या ये बहुभुज हैं? मुझे लगता है कि मुझे लगता है कि वे एक ग्रे पृष्ठभूमि पर लाइनों थे। यदि वे बहुभुज हैं, तो मुझे नहीं पता कि यह अभिविन्यास अवधारणा एक अच्छी है। लेकिन आप सभी इंटरसेक्टिंग सुविधाओं का चयन कर सकते हैं, और यह पता लगा सकते हैं कि कौन से ओवरलैप हैं (एक संघ-प्रकार का टूल चलाएं, और फिर सबसे बड़े क्षेत्र के साथ बहुभुज का उपयोग करें ...)।

Comments

वह तर्क ध्वनि है। मैंने C # / ArcObjects में एक समान दृष्टिकोण का उपयोग किया है, जिसमें अशुद्ध डेटासेट से विशेषताओं को कॉपी करने के लिए विशेषताओं के साथ सटीक डेटासेट के बिना विशेषताओं को कॉपी किया जा सकता है ... 95% सही। तंग क्षेत्रों में मैनुअल चेकिंग / फिक्सिंग आवश्यक थी लेकिन यह सब मैन्युअल रूप से करने की तुलना में निश्चित रूप से तेज था।

— माइकल स्टिमसन

Answer 2

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

मैंने यहाँ उसके बारे में लिखा है ।

1. लेयर पैनल पर अपनी लाल आकार की परत पर राइट क्लिक करें और गुण चुनें ।
2. इसके बाद Joins टैब पर जाएं।
3. प्रेस + बटन, यह नया में शामिल होने बनाएंगे।
4. ज्वाइन लेयर आपकी रेड शेपफाइल लेयर है। ज्वाइन फील्ड दोनों में सामान्य मूल्यों के साथ फील्ड है। लक्ष्य फ़ील्ड वह फ़ील्ड है जिसे आप नीली परत से जोड़ना चाहते हैं।
5. उसके बाद आपको अपनी आकृति तालिका में एक नई विशेषता मिलेगी।

बस।

यहां आपके पास स्क्रीनशॉट के साथ एक उदाहरण है।

Answer 3

मैं @ dmh126 के उत्तर को बहुत पसंद करता हूं क्योंकि उसकी विधि आपकी red_line परत को काफी आसानी से अपडेट करने की अनुमति देती है ।

बस एक विकल्प जोड़ने के लिए, आप प्रोसेसिंग टूलबॉक्स से जॉइन एट्रिब्यूट्स टेबल टूल का उपयोग कर सकते हैं और अपनी परतों को सामान्य फ़ील्ड के साथ चुन सकते हैं। ध्यान दें कि यह विधि किसी मौजूदा को अपडेट करने के बजाय एक नया आकार बनाती है:

Answer 4

यदि आपके पास दोनों लेयर्स में कुछ यूनिक आईडी है, जिसका उपयोग करके आप पुरानी से नई लेयर में आसानी से वैल्यूज को जोड़ सकते हैं, तो यह केक का टुकड़ा है। लेकिन यह उस मामले की तरह प्रतीत नहीं होता है।

यदि नहीं, तो यह बहुत कठिन समस्या है। मुझे आश्चर्य है कि Open3UMP और प्लगइन http://www.vividsolutions.com/products.asp?catg=spaapp&code=roadmatcher का उपयोग करने का सुझाव देते हुए उपयोगकर्ता 30184 की टिप्पणी के बजाय उत्तर के रूप में पोस्ट नहीं किया गया था क्योंकि यह इस मामले में मेरे लिए पूरी तरह से वैध है ।

अन्यथा मुझे नहीं लगता कि आप कुछ कोडिंग के बिना ऐसा कर सकते हैं। क्यूजीआईएस के साथ आप आकार का उपयोग कर सकते हैं और बफरिंग और इंटरसेक्टिंग के संयोजन के दौरान आपको कुछ महत्वपूर्ण स्वचालित जांच करने में सक्षम होना चाहिए।

एक तरीका यह हो सकता है कि नीले रंग की लाइनों के साथ लाल रेखाओं के कुछ बड़े बफर की तुलना करें और मिलान विशेषताओं को प्राप्त करें और इसका मिलान कितना हो। छद्म कोड में:

for r_line in red_lines:
  r_line_buf = r_line.buffer()
  intersecting_b_lines = []
  for b_line in blue_lines:
    if r_line_buf.intersects(b_line):
      intersect_length = calculateIntersectionLength(r_line_buf,b_line)
      b_line_values = getAttributes(b_line)
      intersecting_b_lines.append((b_line_values,intersect_length))
  b_line_best_fit = findLongestLineWithinIntersected(intersecting_b_lines)
  r_line_length = r_line.length
  b_vs_r_line_ratio = compareLength(r_line_length,b_line_best_fit)
  saveToNewColumns(r_line, b_line_best_fit.Atribute1, b_line_best_fit.Atribute2..., b_vs_r_line_ratio)