क्लाइंट बनाम सर्वर

Python और JavaScript के लिए Earth Engine क्लाइंट लाइब्रेरी, जटिल जियोस्पेशियल विश्लेषण को Earth Engine के अनुरोधों में बदलती हैं. क्लाइंट लाइब्रेरी के लिए लिखे गए कोड में, क्लाइंट-साइड ऑब्जेक्ट और वैरिएबल के रेफ़रंस शामिल हो सकते हैं. ये वैरिएबल, सर्वर-साइड ऑब्जेक्ट को दिखाते हैं.

Earth Engine ऑब्जेक्ट को, आपके कोड में मौजूद अन्य Python या JavaScript ऑब्जेक्ट या प्राइमिटिव से अलग करना ज़रूरी है. अपनी स्क्रिप्ट में क्लाइंट-साइड "प्रॉक्सी" ऑब्जेक्ट में बदलाव करके, सर्वर पर ऑब्जेक्ट में बदलाव किया जा सकता है. किसी प्रोक्सी ऑब्जेक्ट को ee से शुरू होने वाले किसी भी ऑब्जेक्ट के तौर पर पहचाना जा सकता है. इन Earth Engine प्रॉक्सी ऑब्जेक्ट में कोई असल डेटा नहीं होता. ये सिर्फ़ सर्वर पर मौजूद ऑब्जेक्ट के हैंडल होते हैं. शुरू करने के लिए, क्लाइंट-साइड स्ट्रिंग ऑब्जेक्ट (जो प्रॉक्सी ऑब्जेक्ट नहीं है) पर विचार करें:

var clientString = 'I am a String';
print(typeof clientString);  // string

import ee
import geemap.core as geemap

client_string = 'I am a String'
print(type(client_string))  # str

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

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

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 को भेजने के लिए किसी चीज़ को कंटेनर में डालने के तरीके के तौर पर देखें. आपके क्लाइंट को यह पता नहीं होता कि कंटेनर में क्या है. हालांकि, इसे प्रिंट करके यह पता लगाया जा सकता है:

print(serverString);  // I am not a String

import ee
import geemap.core as geemap

print(server_string.getInfo())  # I am not a String

कंटेनर कैसा दिखता है, यह देखने के लिए ऑब्जेक्ट की स्ट्रिंग प्रज़ेंटेशन को प्रिंट करें:

print(serverString.toString());  // ee.String("I am not a String!")

import ee
import geemap.core as geemap

print(server_string)  # ee.String({"constantValue": "I am not a String!"})

अगर आपको किसी वजह से, कंटेनर में मौजूद कॉन्टेंट में बदलाव करने के लिए, क्लाइंट में चल रहे Python या JavaScript का इस्तेमाल करना है, तो कंटेनर का कॉन्टेंट पाने और उसे किसी वैरिएबल को असाइन करने के लिए, getInfo() का इस्तेमाल करें:

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

some_string = server_string.getInfo()
strings = some_string + '  Am I?'
print(strings)  # I am not a String!  Am I?

लूप में चलाना

क्लाइंट को यह नहीं पता कि सर्वर-साइड ee.Thing ऑब्जेक्ट में क्या है. इसलिए, क्लाइंट-साइड ऑपरेशन, जैसे कि शर्तें और फ़ॉर-लूप उन पर काम नहीं करते. इस वजह से, getInfo() को सिंक्रोनस कॉल करने से बचने के लिए, जहां तक हो सके सर्वर फ़ंक्शन का इस्तेमाल करें. उदाहरण के लिए, सूची बनाने के लिए, यहां दिए गए दो तरीकों का इस्तेमाल किया जा सकता है:

इसका सुझाव नहीं दिया जाता — क्लाइंट-साइड for-loop

var clientList = [];
for(var i = 0; i < 8; i++) {
  clientList.push(i + 1);
}
print(clientList);

import ee
import geemap.core as geemap

client_list = []
for i in range(8):
  client_list.append(i + 1)
print(client_list)

इसका सुझाव दिया जाता है — सर्वर साइड मैपिंग

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

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 में कास्ट करना ज़रूरी है.

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

var toServerList = ee.List(clientList);

import ee
import geemap.core as geemap

to_server_list = ee.List(client_list)

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

कंडीशनल

ज़रूरी नहीं है कि सर्वर-साइड ऑब्जेक्ट, क्लाइंट-साइड फ़ंक्शन के साथ काम करें. इसके अलावा, क्लाइंट-साइड फ़ंक्शन, सर्वर-साइड ऑब्जेक्ट के साथ भी काम नहीं करते. उदाहरण के लिए, सर्वर-साइड बूलियन वैरिएबल के मामले पर विचार करें:

var myList = ee.List([1, 2, 3]);
var serverBoolean = myList.contains(5);
print(serverBoolean);  // false

import ee
import geemap.core as geemap

my_list = ee.List([1, 2, 3])
server_boolean = my_list.contains(5)
print(server_boolean.getInfo())  # False

नीचे दिए गए उदाहरण में दिखाया गया है कि वैरिएबल, क्लाइंट-साइड कंडीशनल के हिसाब से काम नहीं करता, क्योंकि यह सर्वर-साइड ऑब्जेक्ट है. सर्वर-साइड बूलियन की सही तरीके से जांच करने के लिए, सर्वर-साइड फ़ंक्शन का इस्तेमाल करें:

इसका सुझाव नहीं दिया जाता — क्लाइंट-साइड कंडीशनल

var clientConditional;
if (serverBoolean) {
  clientConditional = true;
} else {
  clientConditional = false;
}
print('Should be false:', clientConditional);  // True!

import ee
import geemap.core as geemap

if server_boolean:
  client_conditional = True
else:
  client_conditional = False
print('Should be False:', client_conditional)  # True!

इसका सुझाव दिया जाता है — सर्वर-साइड कंडीशनल

var serverConditional = ee.Algorithms.If(serverBoolean, 'True!', 'False!');
print('Should be false:', serverConditional);  // False!

import ee
import geemap.core as geemap

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().