आरकेजीआईएस डेस्कटॉप का उपयोग करके रेखापुंज में उच्चतम मूल्यों के स्थानों का पता लगाना?

Question

आर्कजीआईएस 10 का उपयोग करते हुए, मेरे पास एक रेखापुंज है जहां मैं पिक्सेल को रेखापुंज में अधिकतम मूल्य के साथ ढूंढना चाहता हूं और दशमलव स्थान में इसका स्थान (पिक्सेल का केंद्र) लौटा दूंगा। मैं इस प्रक्रिया के माध्यम से पुनरावृत्ति करना चाहूंगा, ताकि दूसरे उच्चतम मूल्य के रेखापुंज का स्थान लौटाया जा सके, फिर तीसरा, और इतने पर कि अंत में मेरे पास एन स्थानों की एक सूची है, जिनके क्रम में रेखापुंज में उच्चतम मान हैं।

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

Comments

क्या आपने X, Y फ़ील्ड्स और सॉर्टिंग को जोड़कर ग्रिड को पॉइंट्स में परिवर्तित करने का प्रयास किया है?

— जैकब सिसक जियोग्राफिक्स

क्या रैस्टर मान फ़्लोट या पूर्णांक हैं?

— whuber

@ याकूब - नहीं, मैंने नहीं। मैं शायद केवल शीर्ष 1% या तो अंक में रुचि रखने जा रहा हूं इसलिए मुझे नहीं पता कि क्या यह सभी बिंदुओं के लिए x, y फ़ील्ड को जोड़ने और फिर छाँटने लायक है। शायद अगर वहाँ एक और अधिक कुशल विकल्प नहीं है?

— mga

@whuber - रेखापुंज मान तैरते हैं।

— मग

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

— जैकब सिसक जियोग्राफिक्स 16

Answer 1

यदि आप R का उपयोग करने में खुश हैं , तो एक पैकेज है जिसे रैस्टर कहा जाता है । आप निम्नलिखित आदेश का उपयोग करके रेखापुंज में पढ़ सकते हैं:

install.packages('raster')
library(raster)
test <- raster('F:/myraster')

फिर, जब आप इसे (टाइप करके test) देखने जाते हैं, तो आप निम्न जानकारी देख सकते हैं:

class       : RasterLayer 
dimensions  : 494, 427, 210938  (nrow, ncol, ncell)
resolution  : 200, 200  (x, y)
extent      : 1022155, 1107555, 1220237, 1319037  (xmin, xmax, ymin, ymax)
coord. ref. : +proj=aea +lat_1=29.5 +lat_2=45.5 +lat_0=23 +lon_0=-96 +x_0=0 +y_0=0 +ellps=GRS80 +datum=NAD83 +units=m +no_defs +towgs84=0,0,0 
values      : F:/myraster 
min value   : 0 
max value   : 1 

रेखापुंज में हेरफेर करने के बेहतर तरीके हो सकते हैं, लेकिन आप जो जानकारी चाहते हैं उसे खोजने का एक तरीका उच्चतम मूल्य मिल सकता है, और यह मैट्रिक्स स्थान प्राप्त कर सकता है, और फिर इसे निचले हिस्सों में जोड़ सकता है।

Comments

इस संदर्भ के लिए +1। एक बार जब आप रेखापुंज को पढ़ लेते हैं R, तो आप मानक Rकार्यों या getValuesसेल मानों तक पहुँचने के लिए विधि का उपयोग कर सकते हैं। वहां से यह उच्चतम मूल्यों और उनके स्थानों की पहचान करने के लिए सीधा है।

— whuber

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

— मग

Answer 2

उत्तर अक्षांश और देशांतर के ग्रिड के साथ शीर्ष 1% मूल्यों के एक संकेतक ग्रिड के संयोजन से प्राप्त किया जा सकता है । ट्रिक इस इंडिकेटर ग्रिड को बनाने में निहित है, क्योंकि आर्कजीआईएस (अभी भी! 40 साल बाद!) के पास रैस्टर डेटा को रैंक करने की कोई प्रक्रिया नहीं है।

फ्लोटिंग-पॉइंट रस्टर्स के लिए एक समाधान पुनरावृत्त है, लेकिन दयापूर्वक त्वरित है । चलो n डेटा कोशिकाओं की संख्या हो। अनुभवजन्य संचयी बंटन (जेड, एन (z)) मान के सभी जोड़े के होते हैं जहां जेड ग्रिड और में एक मूल्य है n (z) की तुलना में कम मूल्यों के साथ ग्रिड में कोशिकाओं की संख्या है या इसके बराबर z । हम एक वक्र को जोड़ते हैं (-इनफिनिटी, 0) से (+ इन्फिनिटी, एन) z द्वारा आदेशित इन शीर्षों के अनुक्रम से । यह इस प्रकार एक फ़ंक्शन f को परिभाषित करता है , जहां (z, f (z)) हमेशा वक्र पर स्थित होता है। आप इस वक्र पर एक बिंदु (z0, 0.99 * n) प्राप्त करना चाहते हैं।

दूसरे शब्दों में, कार्य एक शून्य का f (z) - (1-0.01) * n खोजना है । इसे किसी भी शून्य-खोज दिनचर्या के साथ करें (जो मनमाने कार्यों को संभाल सकता है: यह एक अलग नहीं है)। सबसे सरल, जो अक्सर कुशल होता है, अनुमान और जांच है: शुरू में आपको पता है कि z0 न्यूनतम मान zMin और अधिकतम zMax के बीच स्थित है। इन दोनों के बीच किसी भी उचित मूल्य को सख्ती से मानें। यदि अनुमान बहुत कम है, तो zMin = z0 सेट करें; अन्यथा zMax = z0 सेट करें। अब दोहराएं। आप जल्दी से समाधान के लिए अभिसरण करेंगे; जब zMax और zMin पर्याप्त रूप से बंद हो जाएं तो आप काफी करीब होंगे। रूढ़िवादी होने के लिए, समाधान के रूप में zMin के अंतिम मूल्य को चुनें: इसमें कुछ अतिरिक्त बिंदु हो सकते हैं जिन्हें आप बाद में छोड़ सकते हैं। अधिक परिष्कृत दृष्टिकोणों के लिए, संख्यात्मक व्यंजनों के अध्याय 9 देखें (लिंक एक पुराने मुक्त संस्करण में जाता है)।

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

Answer 3

मैंने कुछ समय पहले ऐसा किया था, हालांकि मेरा समाधान GDAL का उपयोग कर रहा है (इसलिए, यह सिर्फ आर्कजी के लिए नहीं है)। मुझे लगता है कि आप आर्कजीआईएस 10 में एक रेखापुंज से एक न्यूपे सरणी प्राप्त कर सकते हैं, लेकिन मुझे यकीन नहीं है। NumPy सरल और शक्तिशाली सरणी अनुक्रमण, जैसे argsortऔर अन्य की आपूर्ति करता है। यह उदाहरण NODATA को संभालता नहीं है या निर्देशांक को अनुमानित रूप से lat / long में परिवर्तित करता है (लेकिन यह GDAL के साथ उपलब्ध osgeo.osr के साथ करना मुश्किल नहीं है)

import numpy as np
from osgeo import gdal

# Open raster file, and get GeoTransform
rast_src = gdal.Open(rast_fname)
rast_gt = rast_src.GetGeoTransform()

def get_xy(r, c):
    '''Get (x, y) raster centre coordinate at row, column'''
    x0, dx, rx, y0, ry, dy = rast_gt
    return(x0 + r*dx + dx/2.0, y0 + c*dy + dy/2.0)

# Get first raster band
rast_band = rast_src.GetRasterBand(1)

# Retrieve as NumPy array to do the serious work
rast = rast_band.ReadAsArray()

# Sort raster pixels from highest to lowest
sorted_ind = rast.argsort(axis=None)[::-1]

# Show highest top 10 values
for ind in sorted_ind[:10]:
    # Get row, column for index
    r, c = np.unravel_index(ind, rast.shape)
    # Get [projected] X and Y coordinates
    x, y = get_xy(r, c)
    print('[%3i, %3i] (%.3f, %.3f) = %.3f'%
          (r, c, x, y, rast[r, c]))

मेरी परीक्षण रेखापुंज फ़ाइल के लिए निम्नलिखित दिखाता है:

[467, 169] (2813700.000, 6353100.000) = 844.538
[467, 168] (2813700.000, 6353200.000) = 841.067
[469, 168] (2813900.000, 6353200.000) = 840.705
[468, 168] (2813800.000, 6353200.000) = 840.192
[470, 167] (2814000.000, 6353300.000) = 837.063
[468, 169] (2813800.000, 6353100.000) = 837.063
[482, 166] (2815200.000, 6353400.000) = 833.038
[469, 167] (2813900.000, 6353300.000) = 832.825
[451, 181] (2812100.000, 6351900.000) = 828.064
[469, 169] (2813900.000, 6353100.000) = 827.514

Comments

+1 इसे साझा करने के लिए धन्यवाद। मैं एक सीमा के रूप में NoData को संभालने में असमर्थता नहीं देखता: आगे बढ़ने से पहले सभी NoData को अत्यंत नकारात्मक मानों में परिवर्तित करें। ध्यान दें, यह भी कि यदि ग्रिड की किसी भी प्रकार की अस्वीकृति होती है, तो ग्रिड के फिर से शुरू होने के कारण उत्तरों में बदलाव होगा, इसलिए आमतौर पर कोई भी इस तरह की गणना के दौरान पुन: अस्वीकृति नहीं चाहता है। इसके बजाय, रिपोर्ट किए गए निर्देशांक बाद में पुन: उपयोग किए जा सकते हैं। इस प्रकार आपका समाधान पूरी तरह से सामान्य है।

— whuber

NODATA हैंडलिंग को पहले रास्टर से मान प्राप्त करके NODATA = rast_band.GetNoDataValue(), फिर NaN मान ( rast[rast == NODATA] = np.nan) या नकाबपोश सरणी ( rast = np.ma.array(rast, mask=(rast == NODATA))) का उपयोग करके लागू किया जा सकता है । अधिक जटिल चाल argsortकिसी भी तरह से NODATA मानों को विश्लेषण से हटाने के लिए हो रही है, या बस उन्हें अतीत के लूप में छोड़ दें यदि वे NaN / नकाबपोश हैं।

— माइक टी