ArcGIS स्थानिक विश्लेषक का उपयोग करके आपदाओं के सेट के लिए लगातार पिक्सेल मूल्यों की गणना?

Question

मैं स्थानिक विश्लेषक के साथ ArcGIS 10 का उपयोग कर रहा हूं।

मेरे पास चूहों का एक सेट है (कुल में 8) जिसमें प्रत्येक कोशिका के लिए केवल 1 या 0 होता है। प्रत्येक रेखापुंज अलग-अलग वर्षों के डेटा का प्रतिनिधित्व करता है। तर्क 1 वर्ष से 8 वर्ष तक।

मैं सभी आपदाओं को एक साथ जोड़ सकता हूं जो मुझे 0 से 8 तक के मानों के साथ एक अंतिम ग्रिड देगा। यह दर्शाता है कि सेल लगातार 1 वर्ष के चूहों (सभी वर्षों) के सेट के लिए था।

मैं प्रत्येक कोशिका के लिए सबसे लंबे समय तक लगातार संख्या 1 का पता लगाना चाहूंगा।

इसलिए उदाहरण के लिए कुल ग्रिड 5 के मान के एकल कक्ष के लिए रिकॉर्ड कर सकता है, लेकिन 8 ग्रिडों पर सेल की संख्या 1 के बराबर सबसे बड़ी लगातार 3 है। या इसे व्यक्त करने का एक और तरीका 3 साल के लिए है कि सेल 1 था फिर यह शून्य और लोगों के बीच दोलन करना शुरू कर दिया।

मेरे रेखापुंज प्रसंस्करण कौशल मेरे वेक्टर प्रसंस्करण कौशल के रूप में गर्म नहीं है और मुझे ESRI मदद फ़ाइल पर एक अच्छी नज़र है, लेकिन मैं यह पता नहीं लगा सकता कि कोई कैसे शेल्फ जियो-प्रोसेसिंग टूल का उपयोग करके इसे प्राप्त करेगा?

कोई विचार?

Comments

यह वास्तव में एक बहुत अच्छा विश्लेषण है। हमेशा की तरह, एक से अधिक तरीके हैं जो आप करने की कोशिश कर रहे हैं। मुझे लगता है कि आपको सभी संयोजनों के माध्यम से लूप के लिए कुछ प्रोग्रामिंग करने की आवश्यकता है।

— विधिवत

एक सामान्य टिप्पणी (@MLowry द्वारा इस टिप्पणी से प्रेरित): जब भी वे दिलचस्प दिखते हैं या स्पष्ट रूप से व्यक्त की जाती हैं, तो कृपया प्रश्नों को बढ़ाएँ । अच्छे प्रश्न हमारी साइट पर सब कुछ चलाते हैं; कृपया जो हम उनसे पूछते हैं उन्हें पुरस्कृत करने के लिए आइए करते हैं!

— whuber

Answer 1

क्योंकि यह एक स्थानीय ऑपरेशन है, आइए इसे एक सेल के लिए कैसे करें: मैप अलजेब्रा बाकी का ध्यान रखेगा।

पहले ध्यान दें कि दंगों का क्रम स्पष्ट रूप से मायने रखता है। इसलिए एकल-शॉट सेल आंकड़े, जैसे कि सेल योग, ऐसा नहीं करेंगे।

यदि हम किसी दिए गए सेल में 01110101 जैसे अनुक्रम का सामना कर रहे हैं, तो हम इसे शुरू से अंत तक और संसाधित करेंगे

1. शून्य पर एक गिनती के साथ शुरू करें।

2. हर बार जब हम एनकाउंटर करते हैं तो गिनती बढ़ जाती है।

3. पिछली बार की बचत के बाद , हर बार जब हम 0 से मुठभेड़ करते हैं, तो उस संख्या को रीसेट करें ।

4. अंत में, अधिकतम सहेजी गई गणना (अंतिम गणना सहित) लें।

चरण 1 एक निरंतर शून्य ग्रिड के साथ लागू किया जाता है। चरण 2 और 3 इस बात पर निर्भर करते हैं कि हम क्या सामना करते हैं: इसलिए यह एक सशर्त ऑपरेशन है। चरण 4 स्पष्ट रूप से एक स्थानीय अधिकतम है। हम इसे कोड करेंगे, फिर, औपचारिक रूप से थोड़ा और:

count = 0
result = 0
For each value:
    If (value==1):
        count=count+1
    else
        result = max(result, count)
        count=0
result = max(result, count)

यह सबसे अच्छा है जब आप कई ग्रिड होते हैं, पायथन स्क्रिप्ट के साथ, लेकिन आठ के साथ यह लूप को अनियंत्रित करने और हाथ से चरणों को लिखने के लिए बेहतर नहीं है। यह एक मामूली समस्या का खुलासा करता है: result=max(longest,count)एक "साइड-इफ़ेक्ट" की तरह है जो कि रास्टर ऑपरेशन के साथ कोड करना मुश्किल है। (लेकिन यह किया जा सकता है, जैसा कि नीचे दिए गए दूसरे समाधान में दिखाया गया है।) यह भी अक्षम है, क्योंकि यह प्रत्येक चरण में एक अतिरिक्त गणना जोड़ता है। इसलिए हम maxअंत तक ऑपरेशन को बंद रखने के उद्देश्य से दृष्टिकोण को थोड़ा संशोधित करते हैं । इसके लिए प्रत्येक चरण में एक अलग गणना को सहेजना होगा ।

इस प्रक्रिया से गुजरने के दौरान मुझे पहले चरण के लिए एक शॉर्टकट भी मिला। यह निम्नलिखित समाधान की ओर जाता है, जो हालांकि थोड़ा लंबा और रैम-गहन है, सरल है और इसमें जल्दी से निष्पादित कदम शामिल हैं:

result1 = "grid1"
result2 = con("grid2"==1, "result1"+1, 0)
result3 = con("grid3"==1, "result2"+1, 0)
result4 = con("grid4"==1, "result3"+1, 0)
result5 = con("grid5"==1, "result4"+1, 0)
result6 = con("grid6"==1, "result5"+1, 0)
result7 = con("grid7"==1, "result6"+1, 0)
result8 = con("grid8"==1, "result7"+1, 0)
CellStatistics(["result1", "result2", "result3", "result4", "result5", "result6", "result7" "result8"], "max")

वास्तविक सिंटैक्स आपके आर्कपैक के संस्करण के साथ बदलता रहता है। (उदाहरण के लिए, CellStatisticsसंस्करण 10 के लिए नया है, मुझे विश्वास है, लेकिन एक स्थानीय अधिकतम ऑपरेशन हमेशा उपलब्ध रहा है।)

इनपुट 01110101 के साथ उदाहरण में, "परिणाम *" के अनुक्रम में ग्रिड में 0, 1, 2, 3, 0, 1, 0, 1 शामिल होंगे, इसलिए अंत CellStatisticsमें 3, सबसे लंबे स्ट्रिंग की लंबाई लौटेगी 1 के।

यदि रैम दुर्लभ है, तो निष्पादन समय को दोगुना करने की लागत पर, समाधान को मध्यवर्ती परिणामों को फिर से उपयोग करने के लिए संशोधित किया जा सकता है:

result = "grid1"
temp = con("grid2"==1, "result"+1, 0)
result = CellStatistics[["temp", "result"], "max"]
temp = con("grid3"==1, "temp"+1, 0)
result = CellStatistics[["temp", "result"], "max"]
...
temp = con("grid8"==1, "temp"+1, 0)
CellStatistics[["temp", "result"], "max"]

इनपुट के साथ उदाहरण में 01110101, ("अस्थायी", "परिणाम") मान होंगे (NoData, 0) पहली पंक्ति के बाद और ("Con", "CellStatistics") की प्रत्येक जोड़ी के बाद मानों का संचालन होगा (1) , 1), (2, 2), (3, 3), (0, 3), (1, 3), (0, 3), (1, 3)। एक बार फिर अंतिम मूल्य 3 है।

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

Comments

टाइप कोड ब्लॉक में एक टाइपो हो सकता है: काउंट = काउंट = 1 को शायद काउंट = काउंट + 1 होना चाहिए

— MLowry

@ML धन्यवाद (अच्छी आँखें!): यह अब तय हो गया है। स्यूडोकोड को एकदम सही बनाना कठिन है; मानव समीक्षा त्रुटियों को खोजने में एक वास्तविक संपत्ति है। इसके अलावा, हालांकि मैंने आर्कगिस में समाधानों का परीक्षण नहीं किया, मैंने आर में पहला समाधान लागू किया, इसलिए मुझे कुछ आश्वासन है कि दृष्टिकोण सही है।

— whuber

"व्हुबेर" फिर भी आप वह आदमी हैं जो जानता है! यदि आप कभी भी बस से भाग जाते हैं तो भगवान हमारी मदद करते हैं! आपका प्रारंभिक पायथन दृष्टिकोण वह दिशा थी जो मैं सोच रहा था, लेकिन मुझे पता है कि आपदाओं के साथ व्यक्ति अक्सर सब कुछ इतना अस्थिर कर सकता है जिसे आपने साबित कर दिया है। यदि आप अपने आप को ब्रिटेन में पाते हैं, तो यह आपके लिए हमारे सबसे अच्छे कमरे के तापमान फ्लैट बीयर का एक पिंट खरीदने के लिए एक सम्मान होगा! :)

— Hornbydd

धन्यवाद, डंकन: लेकिन एंडी हार्फूट के उत्कृष्ट समाधान की जांच करें!

— whuber

Answer 2

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

यहां आठ ग्रिडों को संयोजित करने का एक तरीका दिखाया गया है:

2*(2*(2*(2*(2*(2*(2*"g8" + "g7") + "g6") + "g5") + "g4") + "g3") + "g2") + "g1"

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

पुनर्वर्गीकरण तालिका आदेश में 00000000B = 0 और 11111111B = 255 के बीच के सभी मानों के लिए अधिकतम रन लंबाई प्रदान करने के लिए है, यहाँ वे हैं:

0, 1, 1, 2, 1, 1, 2, 3, 1, 1, 1, 2, 2, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 3, 2, 2, 2, 2, 3, 3, 4, 5, 1, 1, 1, 2, 1, 1, 2, 3, 1, 1, 1, 2, 2, 2, 3, 4, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 6, 1, 1, 1, 2, 1, 1, 2, 3, 1, 1, 1, 2, 2, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 3, 2, 2, 2, 2, 3, 3, 4, 5, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6, 7, 1, 1, 1, 2, 1, 1, 2, 3, 1, 1, 1, 2, 2, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 3, 2, 2, 2, 2, 3, 3, 4, 5, 1, 1, 1, 2, 1, 1, 2, 3, 1, 1, 1, 2, 2, 2, 3, 4, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 6, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 3, 4, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 3, 3, 4, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8

यह दृष्टिकोण आर्कजीआईएस में लगभग 20 ग्रिडों तक सीमित है: इससे अधिक का उपयोग करने से एक अलौकिक विशेषता तालिका बन सकती है। ( Combineविशेष रूप से 20 ग्रिड तक सीमित है।)

Comments

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

— whuber

Answer 3

क्या आपने 0 और 1 से मानों को 2 (1,2,4,8,16,32) की शक्ति के साथ मूल्यों में बदलने के बारे में सोचा है। जब आप 8 ग्रिडों को जोड़ते हैं, तो आपको प्रत्येक सेल के लिए अद्वितीय मान मिलेंगे जो आपको लगातार जानकारी देंगे (अर्थात: 3 का मान 1 वर्ष और 2 का अर्थ है, जहां 54 का मूल्य 6 से 8 वर्ष होगा)।

सिर्फ एक विचार

Comments

यह ठीक वैसा ही है जैसा @Andy Harfoot ने कुछ घंटे पहले रयान को सुझाया था। :-)

— whuber

धन्यवाद और क्षमा करें। मैं छुट्टी पर अपने फोन पर यह पढ़ रहा हूं।

— रयान गार्नेट