दो 2-डी सरणी एक-दूसरे को ओवरलैप करना शुरू करते हैं?

Question

मैं इस समय मॉडल आउटपुट के साथ काम कर रहा हूं, और मैं डेटा के दो एरे संयोजन के एक अच्छे तरीके से नहीं आ सकता। Arrays ए और बी अलग-अलग डेटा स्टोर करते हैं, और प्रत्येक में प्रविष्टियां कुछ स्थानिक (x, y) बिंदु से मेल खाते हैं - ए में कुछ पैरामीटर होता है, और बी मॉडल आउटपुट रखता है। समस्या यह है कि बी ए का एक स्थानिक उपखंड है - यानी, यदि मॉडल पूरी दुनिया के लिए था, तो ए पृथ्वी पर प्रत्येक बिंदु पर पैरामीटर स्टोर करेगा, और बी केवल अफ्रीका के उन बिंदुओं के लिए मॉडल आउटपुट स्टोर करेगा ।

इसलिए मुझे यह पता लगाना होगा कि बी से कितना ऑफसेट होता है - एक और तरीका है, मुझे उन इंडेक्स को ढूंढना होगा जिन पर वे ओवरलैप करना शुरू कर देते हैं। तो अगर एशप = (1000,1500), बी (750: 850, 200: 300) का हिस्सा है, या (783: 835, 427: 440) उपधारा? मेरे पास ए और बी दोनों से जुड़े सरणी हैं जो प्रत्येक के लिए ग्रिडपॉइंट्स की (x, y) स्थितियों को संग्रहित करती हैं।

यह एक साधारण समस्या प्रतीत होता है - यह पता लगाएं कि दो सरणी ओवरलैप हैं। और मैं इसे scipy.spatial केडीटी के साथ बस हल कर सकता हूं, लेकिन यह बहुत धीमा है। किसी के पास कोई बेहतर विचार है?

Answer 1

मेरे पास ए और बी दोनों से जुड़े सरणी हैं जो प्रत्येक के लिए ग्रिडपॉइंट्स (x, y) स्थितियों को संग्रहीत करती हैं।

उस मामले में, इस सवाल का जवाब काफी सरल होना चाहिए ...

दो ग्रिड एक ही gridding योजना पर सख्ती से कर रहे हैं? मान लिया जाये कि वे कर रहे हैं, तो आप सिर्फ तरह कुछ कर सकते हैं: ग्रिड की indicies के रूप में एक ही दिशा में वृद्धि

np.argwhere((Ax == Bx.min()) & (Ay == By.min())) 

मान लिया जाये कि दुनिया दो ग्रिड के निर्देशांक, इस subsetted ग्रिड के निचले बाएँ कोने देता है।

नीचे दिए गए उदाहरण में, हम स्पष्ट रूप से सिर्फ ix = (Bxmin - Axmin)/dx, आदि से उचित indicies गणना कर सकते हैं (और अगर वे एक ही दिशा (यानी नकारात्मक dx या dy) में वृद्धि नहीं करते, यह सिर्फ अन्य कोनों में से एक देता है) , लेकिन मानते हैं कि आपके पास एक जटिल जटिल प्रणाली है, यह अभी भी काम करेगा। हालांकि, यह माना जा रहा है कि दो ग्रिड एक ही बोली-प्रक्रिया योजना पर हैं! यदि वे नहीं हैं तो यह थोड़ा अधिक जटिल है ...

import numpy as np 

# Generate grids of coordinates from a min, max, and spacing 
dx, dy = 0.5, 0.5 

# For the larger grid... 
Axmin, Axmax = -180, 180 
Aymin, Aymax = -90, 90 

# For the smaller grid... 
Bxmin, Bxmax = -5, 10 
Bymin, Bymax = 30, 40 

# Generate the indicies on a 2D grid 
Ax = np.arange(Axmin, Axmax+dx, dx) 
Ay = np.arange(Aymin, Aymax+dy, dy) 
Ax, Ay = np.meshgrid(Ax, Ay) 

Bx = np.arange(Bxmin, Bxmax+dx, dx) 
By = np.arange(Bymin, Bymax+dy, dy) 
Bx, By = np.meshgrid(Bx, By) 

# Find the corner of where the two grids overlap... 
ix, iy = np.argwhere((Ax == Bxmin) & (Ay == Bymin))[0] 

# Assert that the coordinates are identical. 
assert np.all(Ax[ix:ix+Bx.shape[0], iy:iy+Bx.shape[1]] == Bx) 
assert np.all(Ay[ix:ix+Bx.shape[0], iy:iy+Bx.shape[1]] == By) 

Answer 2

क्या आप और कह सकते हैं? आप किस मॉडल का उपयोग कर रहे हैं? आप मॉडलिंग क्या कर रहे हैं? इसकी गणना कैसे की जाती है?

क्या आप फिट से बचने के लिए आयाम मैच बना सकते हैं? (यानी यदि बी ए के सभी पर निर्भर नहीं है, केवल बी के उन हिस्सों में प्लग करें, या बी के उन हिस्सों के लिए उबाऊ मूल्यों की गणना करें जो ए को ओवरलैप नहीं करेंगे और बाद में उन मानों को छोड़ देंगे)

Answer 3

मुझे उन इंडेक्स को खोजने की ज़रूरत है जिन पर वे

तो क्या आप ए से बी या इंडेक्स की तलाश कर रहे हैं? और बी सख्ती से आयताकार है?

बी के बाध्यकारी बॉक्स या उत्तल हॉल को ढूँढना वास्तव में सस्ता है।