Python और JavaScript के लिए Earth Engine की क्लाइंट लाइब्रेरी, मुश्किल जियोस्पेशल विश्लेषणों को Earth Engine के अनुरोधों में बदलती हैं. क्लाइंट लाइब्रेरी के लिए लिखे गए कोड में, क्लाइंट-साइड ऑब्जेक्ट और सर्वर-साइड ऑब्जेक्ट को दिखाने वाले वैरिएबल के रेफ़रंस का मिश्रण हो सकता है.
यह ज़रूरी है कि Earth Engine के ऑब्जेक्ट को अन्य Python या JavaScript ऑब्जेक्ट या प्रिमिटिव से अलग किया जाए, जो आपके कोड में हो सकते हैं. अपनी स्क्रिप्ट में क्लाइंट-साइड "प्रॉक्सी" ऑब्जेक्ट में बदलाव करके, सर्वर पर मौजूद ऑब्जेक्ट में बदलाव किया जा सकता है. प्रॉक्सी ऑब्जेक्ट की पहचान, ee से शुरू होने वाले किसी भी ऑब्जेक्ट के तौर पर की जा सकती है. इन Earth Engine प्रॉक्सी ऑब्जेक्ट में कोई असल डेटा नहीं होता. ये सिर्फ़ सर्वर पर मौजूद ऑब्जेक्ट के हैंडल होते हैं. शुरू करने के लिए, क्लाइंट-साइड स्ट्रिंग ऑब्जेक्ट पर विचार करें (जो प्रॉक्सी ऑब्जेक्ट नहीं है):
कोड एडिटर (JavaScript)
var clientString = 'I am a String'; print(typeof clientString); // string
import ee import geemap.core as geemap
Colab (Python)
client_string = 'I am a String' print(type(client_string)) # str
आउटपुट से पता चलता है कि क्लाइंट (वेब ब्राउज़र या नोटबुक) ने इस कोड को समझा और चलाया. इससे यह तय हुआ कि वैरिएबल string टाइप का है. अब मान लें कि आपको Earth Engine से इस स्ट्रिंग के साथ कुछ करवाना है. इसके लिए, आपको स्ट्रिंग को एक अच्छे कंटेनर में रैप करना होगा और उसे Google को भेजना होगा. वह कंटेनर, प्रॉक्सी ऑब्जेक्ट होता है. यहां एक उदाहरण दिया गया है:
कोड एडिटर (JavaScript)
var serverString = ee.String('I am not a String!'); print(typeof serverString); // object print('Is this an EE object?', serverString instanceof ee.ComputedObject); // true
import ee import geemap.core as geemap
Colab (Python)
server_string = ee.String('I am not a String!') print(type(server_string)) # ee.ee_string.String print( 'Is this an EE object?', isinstance(server_string, ee.ee_string.String) ) # True
आउटपुट से पता चलता है कि ee.String एक object है, न कि string. खास तौर पर, यह एक ee.computedObject है. इसका मतलब है कि यह सर्वर पर मौजूद किसी चीज़ के लिए प्रॉक्सी ऑब्जेक्ट है. ee.Thing को एक ऐसे कंटेनर की तरह समझें जिसमें Google को भेजने के लिए चीज़ें रखी जाती हैं. आपके क्लाइंट को नहीं पता कि कंटेनर में क्या है. हालांकि, इसे प्रिंट करके यह पता लगाया जा सकता है कि इसमें क्या है:
कोड एडिटर (JavaScript)
print(serverString); // I am not a String
import ee import geemap.core as geemap
Colab (Python)
print(server_string.getInfo()) # I am not a String
कंटेनर कैसा दिखता है, यह देखने के लिए ऑब्जेक्ट की स्ट्रिंग को प्रिंट करें:
कोड एडिटर (JavaScript)
print(serverString.toString()); // ee.String("I am not a String!")
import ee import geemap.core as geemap
Colab (Python)
print(server_string) # ee.String({"constantValue": "I am not a String!"})
अगर किसी वजह से आपको कंटेनर में मौजूद कॉन्टेंट में बदलाव करने के लिए, क्लाइंट में चल रहे Python या JavaScript का इस्तेमाल करना है, तो कंटेनर का कॉन्टेंट पाने और उसे किसी वैरिएबल को असाइन करने के लिए, getInfo() का इस्तेमाल करें:
कोड एडिटर (JavaScript)
var someString = serverString.getInfo(); var strings = someString + ' Am I?'; print(strings); // I am not a String! Am I?
import ee import geemap.core as geemap
Colab (Python)
some_string = server_string.getInfo() strings = some_string + ' Am I?' print(strings) # I am not a String! Am I?
लूप
क्लाइंट को यह नहीं पता होता कि सर्वर-साइड ee.Thing ऑब्जेक्ट में क्या है. इसलिए, क्लाइंट-साइड ऑपरेशन, जैसे कि कंडीशनल और for-loop, इनके साथ काम नहीं करते. इस वजह से और getInfo() को सिंक्रोनस कॉल से बचने के लिए, ज़्यादा से ज़्यादा सर्वर फ़ंक्शन का इस्तेमाल करें. उदाहरण के लिए, सूची बनाने के इन दो तरीकों पर ध्यान दें:
इसका सुझाव नहीं दिया जाता — क्लाइंट-साइड for-loop
कोड एडिटर (JavaScript)
var clientList = []; for(var i = 0; i < 8; i++) { clientList.push(i + 1); } print(clientList);
import ee import geemap.core as geemap
Colab (Python)
client_list = [] for i in range(8): client_list.append(i + 1) print(client_list)
इसका सुझाव दिया जाता है — सर्वर साइड मैपिंग
कोड एडिटर (JavaScript)
var serverList = ee.List.sequence(0, 7); serverList = serverList.map(function(n) { return ee.Number(n).add(1); }); print(serverList);
import ee import geemap.core as geemap
Colab (Python)
server_list = ee.List.sequence(0, 7) server_list = server_list.map(lambda n: ee.Number(n).add(1)) print(server_list.getInfo())
सर्वर-साइड मैपिंग का उदाहरण थोड़ा अजीब है, क्योंकि ee.List.sequence(1, 8) का इस्तेमाल करके भी वही सूची बनाई जा सकती है. हालांकि, इससे कुछ अहम कॉन्सेप्ट के बारे में पता चलता है. पहला कॉन्सेप्ट है map(). यह सूची में मौजूद हर चीज़ पर एक ही फ़ंक्शन लागू करता है. यह फ़ंक्शन सर्वर पर लागू होता है. इसलिए, क्लाइंट-साइड फ़ंक्शन, जैसे कि getInfo() और print(), मैप किए गए फ़ंक्शन में काम नहीं करेंगे. इस वजह से, i + 1 कोड को इसके बराबर के सर्वर-साइड कोड से बदलना होगा: ee.Number(n).add(1). अहम बात यह है कि n एक ऐसा ऑब्जेक्ट है
जो सिर्फ़ सर्वर पर मौजूद होता है. फ़ंक्शन को अपने आर्ग्युमेंट के टाइप की जानकारी नहीं होती. इसलिए, इसे ee.Number में कास्ट करना ज़रूरी है.
यह भी ध्यान देने वाली बात है कि कभी-कभी क्लाइंट-साइड फ़ंक्शन का इस्तेमाल करना आसान होता है. उदाहरण के लिए, पिछली बार इस्तेमाल किए गए लूप का इस्तेमाल करके, एक सूची बनाई जा सकती है और उसे सर्वर-साइड ऑब्जेक्ट के साथ रैप किया जा सकता है:
कोड एडिटर (JavaScript)
var toServerList = ee.List(clientList);
import ee import geemap.core as geemap
Colab (Python)
to_server_list = ee.List(client_list)
ध्यान रखें कि क्लाइंट-साइड प्रोसेसिंग, आपकी नोटबुक या ब्राउज़र में की जाती है. यह होस्ट मशीन के सीपीयू में की जाती है. इसलिए, यह सर्वर पर काम करने के लिए Earth Engine का इस्तेमाल करने की तुलना में कम असरदार हो सकती है. साथ ही, अनचाहे नतीजों से बचने के लिए, अपनी स्क्रिप्ट में क्लाइंट और सर्वर की सुविधाओं को मिक्स करने से बचें. कंडिशनल सेक्शन में, अनचाहे नतीजों का एक उदाहरण दिया गया है.
कंडीशनल
यह ज़रूरी नहीं है कि सर्वर-साइड ऑब्जेक्ट, क्लाइंट-साइड फ़ंक्शन के साथ काम करें. इसी तरह, यह भी ज़रूरी नहीं है कि क्लाइंट-साइड ऑब्जेक्ट, सर्वर-साइड फ़ंक्शन के साथ काम करें. उदाहरण के लिए, सर्वर-साइड बूलियन वैरिएबल का मामला देखें:
कोड एडिटर (JavaScript)
var myList = ee.List([1, 2, 3]); var serverBoolean = myList.contains(5); print(serverBoolean); // false
import ee import geemap.core as geemap
Colab (Python)
my_list = ee.List([1, 2, 3]) server_boolean = my_list.contains(5) print(server_boolean.getInfo()) # False
नीचे दिए गए उदाहरण में दिखाया गया है कि वैरिएबल, क्लाइंट-साइड की शर्त के हिसाब से काम नहीं करता, क्योंकि यह सर्वर-साइड ऑब्जेक्ट है. सर्वर-साइड बूलियन की सही तरीके से जांच करने के लिए, सर्वर-साइड फ़ंक्शन का इस्तेमाल करें:
इसका सुझाव नहीं दिया जाता है — क्लाइंट-साइड कंडीशनल
कोड एडिटर (JavaScript)
var clientConditional; if (serverBoolean) { clientConditional = true; } else { clientConditional = false; } print('Should be false:', clientConditional); // True!
import ee import geemap.core as geemap
Colab (Python)
if server_boolean: client_conditional = True else: client_conditional = False print('Should be False:', client_conditional) # True!
इसका सुझाव दिया जाता है — सर्वर-साइड कंडीशनल
कोड एडिटर (JavaScript)
var serverConditional = ee.Algorithms.If(serverBoolean, 'True!', 'False!'); print('Should be false:', serverConditional); // False!
import ee import geemap.core as geemap
Colab (Python)
server_conditional = ee.Algorithms.If(server_boolean, 'True!', 'False!') print('Should be False:', server_conditional.getInfo()) # False!
क्लाइंट और सर्वर फ़ंक्शन
पिछले सेक्शन में ऐसी कई वजहें बताई गई हैं जिनकी वजह से, क्लाइंट और सर्वर ऑब्जेक्ट और फ़ंक्शन को मिलाना गलत या बेअसर होता है. कौनसे ऑब्जेक्ट और फ़ंक्शन क्लाइंट-साइड हैं और कौनसे सर्वर-साइड हैं? आम तौर पर, ee.Thing के तौर पर शुरू की गई कोई भी चीज़, सर्वर ऑब्जेक्ट होती है. साथ ही, उस ऑब्जेक्ट पर मौजूद कोई भी तरीका, ee.Thing.method(), सर्वर फ़ंक्शन होता है. Python या JavaScript रेफ़रंस में दिखने वाले ऑब्जेक्ट और फ़ंक्शन, क्लाइंट-साइड होते हैं. जैसा कि पहले बताया गया है, क्लाइंट-साइड फ़ंक्शन का इस्तेमाल करके कोई ऑब्जेक्ट बनाया जा सकता है. इसके बाद, क्लाइंट-साइड ऑब्जेक्ट को Earth Engine कंस्ट्रक्टर को देकर, उसे रैप किया जा सकता है. उदाहरण के लिए, ee.String().