Earth Engine का इस्तेमाल शुरू करना

'शुरू करें' गाइड का मकसद, Earth Engine JavaScript API की मदद से प्रोग्रामिंग शुरू करने का तेज़ तरीका बताना है. JavaScript के बारे में बुनियादी जानकारी पाने और Earth Engine API के साथ ज़्यादा जानकारी वाले अभ्यास करने के लिए, ट्यूटोरियल देखें. JavaScript कोडिंग स्टाइल के सुझाव पाने के लिए, Google की JavaScript स्टाइल वाली गाइड देखें.

Google Earth Engine की मदद से, उपयोगकर्ता Google के इंफ़्रास्ट्रक्चर पर सेव की गई, जगह की जानकारी वाली इमेज और वेक्टर पर एल्गोरिदम चला सकते हैं. Google Earth Engine API, फ़ंक्शन की एक लाइब्रेरी उपलब्ध कराता है. इसे डेटा को दिखाने और उसका विश्लेषण करने के लिए इस्तेमाल किया जा सकता है. Earth Engine के सार्वजनिक डेटा कैटलॉग में, सार्वजनिक तौर पर उपलब्ध बहुत सारी इमेज और वेक्टर डेटासेट मौजूद हैं. निजी ऐसेट, उपयोगकर्ताओं के निजी फ़ोल्डर में भी बनाई जा सकती हैं.

इन दस्तावेज़ों को इस्तेमाल करने का तरीका

Earth Engine के दस्तावेज़, जियोस्पेशियल डेटा विश्लेषण के बारे में जानने वाले लोगों के लिए डिज़ाइन किए गए हैं. दस्तावेज़ों को मुख्य रूप से डेटा टाइप के हिसाब से व्यवस्थित किया जाता है. उदाहरण के लिए, बाईं ओर मौजूद नेविगेशन में, Image, ImageCollection, Feature, FeatureCollection, Geometry, Reducer, Chart, Join, और Array जैसे अहम डेटा टाइप के सेक्शन या पेजों के लिंक मौजूद होते हैं. इस गाइड में, इन टाइप के बारे में सिर्फ़ इतना बताया गया है कि आप इनका इस्तेमाल शुरू कर सकें. यहां मशीन लर्निंग, खास या सेंसर के हिसाब से एल्गोरिदम (उदाहरण के लिए, Landsat एल्गोरिदम), सार्वजनिक ऐप्लिकेशन, डेटा (एसेट) मैनेजमेंट, और Earth Engine के अंदरूनी काम करने के तरीके के बारे में अहम जानकारी वाले सेक्शन भी हैं. इनमें से किसी भी सुविधा का इस्तेमाल करने से पहले, यहां जाएं!

कोड एडिटर

कोड एडिटर, Earth Engine ऐप्लिकेशन बनाने के लिए एक इंटरैक्टिव प्लैटफ़ॉर्म है (पहली इमेज). सेंटर पैनल में, JavaScript कोड एडिटर होता है. एडिटर के ऊपर, मौजूदा स्क्रिप्ट को सेव करने, उसे चलाने, और मैप को मिटाने के लिए बटन होते हैं. लिंक पाएं बटन, स्क्रिप्ट के लिए यूनीक यूआरएल जनरेट करता है. यह यूआरएल, पता बार में दिखता है. सबसे नीचे मौजूद पैनल में मौजूद मैप में, स्क्रिप्ट से जोड़ी गई लेयर होती हैं. सबसे ऊपर, डेटासेट और जगहों के लिए खोज बॉक्स है. बाएं पैनल में, कोड के उदाहरण, सेव की गई स्क्रिप्ट, खोजे जा सकने वाले एपीआई का रेफ़रंस, और निजी डेटा के लिए एसेट मैनेजर शामिल होता है. दाएं पैनल में, मैप से जुड़ी क्वेरी के लिए एक इंस्पेक्टर, आउटपुट कंसोल, और लंबे समय से चल रहे टास्क के लिए एक मैनेजर होता है. सबसे ऊपर दाईं ओर मौजूद, सहायता बटन help में इस गाइड और सहायता पाने के लिए अन्य संसाधनों के लिंक मौजूद हैं. कोड एडिटर गाइड और सहायता पाएं गाइड से ज़्यादा जानें.

कोड एडिटर में कोड खोलना और चलाना

यहां Earth Engine खोलने और इमेज दिखाने वाली कस्टम स्क्रिप्ट को चलाने का तरीका बताया गया है. सबसे अच्छे नतीजे पाने के लिए, Google के वेब ब्राउज़र Chrome का नया वर्शन इंस्टॉल करें. यह वर्शन यहां उपलब्ध है.

1. Earth Engine कोड एडिटर यहां खोलें: code.earthengine.google.com.
2. कोड एडिटर में सबसे बाईं ओर मौजूद, स्क्रिप्ट टैब पर जाएं. वहां आपको उदाहरण के तौर पर ऐसी स्क्रिप्ट का कलेक्शन मिलेगा जो Earth Engine के डेटा को ऐक्सेस करती हैं, दिखाती हैं, और उसका विश्लेषण करती हैं.
3. “इमेज कलेक्शन” में जाकर, “फ़िल्टर किया गया कंपोजिट” उदाहरण चुनें. आपको सेंटर कंसोल में एक स्क्रिप्ट दिखेगी. स्क्रिप्ट को चलाने के लिए, चालू करें बटन दबाएं. फ़िल्टर किए गए कंपोजिट के उदाहरण में, कोलोराडो और यूटा की सीमाओं में मौजूद या उनसे इंटरसेक्शन वाली Landsat 7 इमेज चुनी जाती हैं. इसके बाद, यह चुने गए इमेज का सच्चा रंग दिखाता है. सैंपल में, आम तौर पर इस्तेमाल किए जाने वाले तरीकों के बारे में बताया गया है. जैसे, filter(), clip(), और Map.addLayer().

Earth Engine के डेटा स्ट्रक्चर

Earth Engine में भौगोलिक डेटा के दो सबसे बुनियादी स्ट्रक्चर, Image और Feature हैं. ये क्रमशः रास्टर और वेक्टर डेटा टाइप से जुड़े होते हैं. इमेज, बैंड और प्रॉपर्टी की डिक्शनरी से बनी होती हैं. फ़ीचर में Geometry और प्रॉपर्टी की एक डिक्शनरी होती है. इमेज के स्टैक (उदाहरण के लिए, इमेज की टाइम सीरीज़) को ImageCollection मैनेज करता है. सुविधाओं के कलेक्शन को FeatureCollection मैनेज करता है. Earth Engine में, Dictionary, List, Array, Date, Number, और String जैसे अन्य बुनियादी डेटा स्ट्रक्चर भी शामिल हैं. इस ट्यूटोरियल से, बुनियादी डेटा टाइप के बारे में ज़्यादा जानें. यह ध्यान रखना ज़रूरी है कि ये सभी सर्वर-साइड ऑब्जेक्ट हैं और इनमें बदलाव उसी तरह नहीं किया जाता है जिस तरह क्लाइंट-साइड JavaScript ऑब्जेक्ट में किया जाता है (ज़्यादा जानें).

Earth Engine के एल्गोरिदम

एपीआई में ऑपरेशन चलाने के कई तरीके हैं:

• ऑब्जेक्ट से जुड़े मेथड को कॉल करना.
• एल्गोरिदम को कॉल करना.
• कोड एडिटर के खास फ़ंक्शन को कॉल करना.
• नए फ़ंक्शन तय करना.

कोड एडिटर के दस्तावेज़ टैब में, हर एपीआई क्लास के तरीके दिखते हैं. उदाहरण के लिए, Image क्लास में add() तरीका है:

var image3 = image1.add(image2);

इस तरीके से, image2 के बैंड को image1 के बैंड में जोड़ा जाता है. ee.Algorithms कैटगरी में, खास या डोमेन के हिसाब से प्रोसेसिंग के लिए, फ़िलहाल काम करने वाले एल्गोरिदम की सूची होती है. उदाहरण के लिए, इनपुट डिजिटल एलिवेशन मॉडल (डीईएम) से, टोपोग्राफ़िक लेयर बनाने के लिए:

var terrainImage = ee.Algorithms.Terrain(dem);

कोड एडिटर के खास फ़ंक्शन में Map और Export तरीके शामिल हैं. इनसे यह कंट्रोल किया जाता है कि लेयर को मैप पैनल में कैसे जोड़ा जाए या Google Drive में कैसे एक्सपोर्ट किया जाए. JavaScript में फ़ंक्शन बनाने के लिए,

var myFunction = function(args) {
  // do something
  return something;
};

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

var collection2 = collection1.map(aFunction);

नीचे दिए गए सेक्शन में, इस्तेमाल के अलग-अलग उदाहरणों के लिए इन कॉन्सेप्ट के बारे में बताया गया है.

'नमस्ते दुनिया!' JavaScript

किसी ऑब्जेक्ट के बारे में जानकारी पाने, कैलकुलेशन का संख्या वाला नतीजा दिखाने, ऑब्जेक्ट का मेटाडेटा दिखाने या डीबग करने में मदद करने के लिए, जानकारी को कंसोल पर प्रिंट करना एक बुनियादी काम है. कोड एडिटर में, 'नमस्ते दुनिया!' का उदाहरण यह है:

print('Hello world!');

इस लाइन को कोड एडिटर में कॉपी करें और चालू करें पर क्लिक करें. ध्यान दें कि आउटपुट, कोड एडिटर की दाईं ओर मौजूद कंसोल टैब में दिखता है. रिमोट सेंसिंग से जुड़े ज़्यादा काम के उदाहरण के लिए, यहां Landsat 8 इमेज का मेटाडेटा प्रिंट किया गया है:

print(ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318'));

Landsat इमेज के लिए उपलब्ध मेटाडेटा देखने के लिए, कंसोल में आउटपुट की ध्यान से जांच करें.

मैप में डेटा जोड़ना

कंसोल में जानकारी प्रिंट करने के अलावा, Map में डेटा जोड़कर भी भौगोलिक डेटा को विज़ुअलाइज़ किया जा सकता है. ऐसा करने के लिए, Map.addLayer() का इस्तेमाल करें. यहां दिए गए उदाहरण में, ee.Image() का इस्तेमाल करके Image को इंस्टैंशिएट किया गया है. इन इमेज को ढूंढने का तरीका बाद में बताया गया है. इमेज को मैप में Map.addLayer() की मदद से जोड़ा गया है और मैप को इमेज के बीच में सेट किया गया है:

// Load an image.
var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318');

// Center the map on the image.
Map.centerObject(image, 9);

// Display the image.
Map.addLayer(image);

Map.centerObject() का दूसरा पैरामीटर ज़ूम लेवल होता है. इसमें बड़ी संख्याएं, बड़े स्केल (ज़्यादा ज़ूम इन) को दिखाती हैं. Map फ़ंक्शन के पैरामीटर के बारे में ज़्यादा जानकारी, एपीआई रेफ़रंस में दी गई है. इसे Docs टैब से ऐक्सेस किया जा सकता है. अगर इमेज ठीक से नहीं दिख रही है, तो Map.addLayer() के लिए एक और आर्ग्युमेंट के साथ डिसप्ले पैरामीटर कॉन्फ़िगर करें. उदाहरण के लिए:

// Load the image from the archive.
var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318');

// Define visualization parameters in an object literal.
var vizParams = {bands: ['B5', 'B4', 'B3'], min: 0.02, max: 0.4, gamma: 1.3};

// Center the map on the image and display.
Map.centerObject(image, 9);
Map.addLayer(image, vizParams, 'Landsat 8 false color');

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

मैप में सुविधाएं और सुविधाओं के कलेक्शन जोड़ने के लिए, Map.addLayer() का इस्तेमाल करें. उदाहरण के लिए,

var counties = ee.FeatureCollection('TIGER/2018/Counties');
Map.addLayer(counties, {}, 'counties');

इमेज, इमेज कलेक्शन, और सुविधाओं के कलेक्शन ढूंढना

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

इसके अलावा, कलेक्शन आईडी को कॉपी करके अपने कोड में चिपकाएं. उदाहरण के लिए, 'Landsat 8' खोज के लिए, टीयर 1 TOA का नतीजा चुनें और आईडी को इस तरह कॉपी करें:

var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA');

यह Earth के लैंड सरफ़ेस की कई इमेज का कलेक्शन है. इसलिए, कलेक्शन में किसी एक इमेज को ढूंढने के लिए, खोज को सटीक बनाने के लिए फ़िल्टर करना ज़रूरी है. इसके अलावा, कॉम्पोज़िटिंग और मोज़ेक बनाने की तकनीकों का इस्तेमाल करके, इमेज के कलेक्शन को एक इमेज में बदला जा सकता है. फ़िल्टर करने और कॉम्पोज़ करने के बारे में ज़्यादा जानकारी के लिए, अगले सेक्शन में कम करना देखें.

डेटा कैटलॉग में भी सुविधाओं के कलेक्शन उपलब्ध होते हैं. इमेज कलेक्शन की तुलना में, इनका रिप्रज़ेंटेशन कम होता है. हालांकि, आपको इनमें अंतरराष्ट्रीय, जनगणना, जलक्षेत्र, और संरक्षित इलाकों की सीमाएं दिखेंगी. अपने वेक्टर डेटासेट को इंपोर्ट करने के बारे में ज़्यादा जानने के लिए, यहां जाएं.

फ़िल्टर करना और क्रम से लगाना

नतीजों की संख्या को सीमित करने के लिए, अक्सर किसी कलेक्शन को जगह और/या समय के हिसाब से फ़िल्टर करना ज़रूरी होता है. उदाहरण के लिए, सैन फ़्रांसिस्को की साफ़ आसमान वाली तस्वीर ढूंढने के लिए, Landsat 8 के सीन कलेक्शन को क्रम से लगाने का टास्क लें. सबसे पहले, अपनी दिलचस्पी के क्षेत्र को तय करना ज़रूरी है. इसके लिए, अक्सर पॉइंट का इस्तेमाल किया जाता है. कोड एडिटर की दाईं ओर मौजूद, इंस्पेक्टर टैब को चालू करें और अपनी पसंद के इलाके के केंद्र के पास क्लिक करें. इसके बाद, इंस्पेक्टर टैब से निर्देशांक कॉपी करें और इनका इस्तेमाल करके Point बनाएं:

var point = ee.Geometry.Point(-122.262, 37.8719);

शुरू और खत्म होने की तारीखें तय करना:

var start = ee.Date('2014-06-01');
var finish = ee.Date('2014-10-01');

पॉइंट और तारीखों का इस्तेमाल करके, लैंडसैट 8 कलेक्शन को फ़िल्टर करें. इसके बाद, मेटाडेटा की किसी प्रॉपर्टी का इस्तेमाल करके क्रम से लगाएं (यह प्रॉपर्टी, लैंडसैट 8 सीन के मेटाडेटा की जांच के दौरान मिली थी):

var filteredCollection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
  .filterBounds(point)
  .filterDate(start, finish)
  .sort('CLOUD_COVER', true);

इस कलेक्शन को सुरक्षित तरीके से प्रिंट किया जा सकता है और इसकी जांच की जा सकती है. (अगर कलेक्शन में बहुत ज़्यादा इमेज हैं, तो उसे प्रिंट करने में काफ़ी समय लगेगा, टाइम आउट होगा या गड़बड़ी का मैसेज दिखेगा). ध्यान दें कि कलेक्शन में मौजूद इमेज, ImageCollection की 'सुविधाएं' प्रॉपर्टी में सेव की गई List हैं. कलेक्शन में मौजूद किसी भी इमेज का आईडी, ऊपर बताए गए तरीके से Image कन्स्ट्रक्टर में कॉपी किया जा सकता है. इसके अलावा, पहली इमेज (कम से कम बादल) पाने के लिए:

var first = filteredCollection.first();

आर्ग्युमेंट के तौर पर ee.Filter का इस्तेमाल करके, filter() का इस्तेमाल करके Earth Engine की फ़िल्टर करने की पूरी सुविधा ऐक्सेस करें. (ऊपर इस्तेमाल किए गए filterBounds() और filterDate() तरीके शॉर्टकट हैं). उदाहरण के लिए, नीचे दिया गया उदाहरण, Filter बनाता है, FeatureCollection को फ़िल्टर करने के लिए उसका इस्तेमाल करता है, और नतीजा दिखाता है:

// Load a feature collection.
var featureCollection = ee.FeatureCollection('TIGER/2016/States');

// Filter the collection.
var filteredFC = featureCollection.filter(ee.Filter.eq('NAME', 'California'));

// Display the collection.
Map.setCenter(-119.604, 37.798, 6);
Map.addLayer(filteredFC, {}, 'California');

बैंड मैथ

Image तरीकों का इस्तेमाल करके, इमेज पर गणित के ऑपरेशन करें. इसमें, बैंड रीकॉम्बिनेशन (स्पेक्ट्रल इंडेक्स), इमेज में अंतर या गणितीय ऑपरेशन शामिल हो सकते हैं. जैसे, किसी संख्या से गुणा करना. उदाहरण के लिए, 20 साल के अंतर वाली, नॉर्मलाइज़्ड डिफ़रेंस वेजिटेशन इंडेक्स (एनडीवीआई) इमेज के बीच का अंतर कैलकुलेट करें:

// This function gets NDVI from Landsat 5 imagery.
var getNDVI = function(image) {
  return image.normalizedDifference(['B4', 'B3']);
};

// Load two Landsat 5 images, 20 years apart.
var image1 = ee.Image('LANDSAT/LT05/C02/T1_TOA/LT05_044034_19900604');
var image2 = ee.Image('LANDSAT/LT05/C02/T1_TOA/LT05_044034_20100611');

// Compute NDVI from the scenes.
var ndvi1 = getNDVI(image1);
var ndvi2 = getNDVI(image2);

// Compute the difference in NDVI.
var ndviDifference = ndvi2.subtract(ndvi1);

इस उदाहरण में, उपयोगकर्ता के तय किए गए function के इस्तेमाल पर ध्यान दें. अगले सेक्शन में, फ़ंक्शन के बारे में ज़्यादा जानें.

मैपिंग (for-loop के बजाय क्या करना है)

किसी कलेक्शन में मौजूद आइटम पर बार-बार जाने के लिए, map() का इस्तेमाल करें. (Earth Engine में ऐसा करने के लिए, For लूप का इस्तेमाल करना सही तरीका नहीं है. इसलिए, इसका इस्तेमाल नहीं किया जाना चाहिए). map() फ़ंक्शन को ImageCollection, FeatureCollection या List पर लागू किया जा सकता है. साथ ही, यह अपने आर्ग्युमेंट के तौर पर function को स्वीकार करता है. फ़ंक्शन का आर्ग्युमेंट, उस कलेक्शन का एलिमेंट होता है जिस पर इसे मैप किया गया है. यह संग्रह के हर एलिमेंट में एक ही तरह से बदलाव करने के लिए मददगार होता है. उदाहरण के लिए, जोड़ना. उदाहरण के लिए, यह कोड ImageCollection में मौजूद हर इमेज में एनडीवीआई बैंड जोड़ता है:

// This function gets NDVI from Landsat 8 imagery.
var addNDVI = function(image) {
  return image.addBands(image.normalizedDifference(['B5', 'B4']));
};

// Load the Landsat 8 TOA data, filter by location and date.
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
  .filterBounds(ee.Geometry.Point(-122.262, 37.8719))
  .filterDate('2014-06-01', '2014-10-01');

// Map the function over the collection.
var ndviCollection = collection.map(addNDVI);

एक और सामान्य टास्क, किसी FeatureCollection में सुविधाओं में नई प्रॉपर्टी (या 'एट्रिब्यूट' या 'फ़ील्ड') जोड़ना है. नीचे दिए गए उदाहरण में, नई प्रॉपर्टी, दो मौजूदा एट्रिब्यूट के आधार पर तय की गई है:

// This function creates a new property that is the sum of two existing properties.
var addField = function(feature) {
  var sum = ee.Number(feature.get('property1')).add(feature.get('property2'));
  return feature.set({'sum': sum});
};

// Create a FeatureCollection from a list of Features.
var features = ee.FeatureCollection([
  ee.Feature(ee.Geometry.Point(-122.4536, 37.7403),
    {property1: 100, property2: 100}),
    ee.Feature(ee.Geometry.Point(-118.2294, 34.039),
    {property1: 200, property2: 300}),
]);

// Map the function over the collection.
var featureCollection = features.map(addField);

// Print a selected property of one Feature.
print(featureCollection.first().get('sum'));

// Print the entire FeatureCollection.
print(featureCollection);

ध्यान दें कि add() तरीके का इस्तेमाल करने के लिए, प्रॉपर्टी की वैल्यू को संख्या के तौर पर पहचानने के लिए, ee.Number में बदलना ज़रूरी है). map() की मदद से, कलेक्शन का टाइप बदला जा सकता है. उदाहरण के लिए:

// This function returns the image centroid as a new Feature.
var getGeom = function(image) {
  return ee.Feature(image.geometry().centroid(), {foo: 1});
};

// Load a Landsat 8 TOA collection.
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
  .filterBounds(ee.Geometry.Point(-122.262, 37.8719))
  .filterDate('2014-06-01', '2014-10-01');

// Map the function over the ImageCollection.
var featureCollection = ee.FeatureCollection(collection.map(getGeom));

// Print the collection.
print(featureCollection);

इमेज के सेंट्राइड से बनाई गई हर विशेषता के लिए, जोड़ी गई प्रॉपर्टी (foo) पर ध्यान दें. आखिरी लाइन में, कास्ट की मदद से, नतीजे के तौर पर मिले कलेक्शन को FeatureCollection के तौर पर पहचाना जा सकता है.

कम करना

Earth Engine में समय, जगह, बैंड, ऐरे, और अन्य डेटा स्ट्रक्चर के हिसाब से डेटा इकट्ठा करने का तरीका, कम करना है. एपीआई में इस काम के लिए कई तरीके मौजूद हैं. उदाहरण के लिए, ImageCollection का कंपोजिट बनाने के लिए, reduce() का इस्तेमाल करके, कलेक्शन में मौजूद इमेज को एक इमेज में बदलें. उदाहरण के लिए, पहले बताए गए Landsat 8 कलेक्शन में, सबसे कम बादल वाले पांच फ़ोटो से मेडियन कंपोजिट बनाना:

// Load a Landsat 8 TOA collection.
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
  // Filter by date and location.
  .filterBounds(ee.Geometry.Point(-122.262, 37.8719))
  .filterDate('2014-01-01', '2014-12-31')
  // Sort by increasing cloudiness.
  .sort('CLOUD_COVER');

// Compute the median of each pixel for each band of the 5 least cloudy scenes.
var median = collection.limit(5).reduce(ee.Reducer.median());

Feature या FeatureCollection से तय किए गए इलाकों में किसी इमेज के आंकड़े पाने के लिए भी, इमेज को छोटा किया जा सकता है. मान लें कि आपको किसी दिलचस्प इलाके में, पिक्सल की औसत वैल्यू का हिसाब लगाना है. इस काम के लिए, reduceRegion() का इस्तेमाल करें. उदाहरण के लिए:

// Load and display a Landsat TOA image.
var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318');
Map.addLayer(image, {bands: ['B4', 'B3', 'B2'], max: 0.3});

// Create an arbitrary rectangle as a region and display it.
var region = ee.Geometry.Rectangle(-122.2806, 37.1209, -122.0554, 37.2413);
Map.addLayer(region);

// Get a dictionary of means in the region.  Keys are bandnames.
var mean = image.reduceRegion({
  reducer: ee.Reducer.mean(),
  geometry: region,
  scale: 30
});

Reducers दस्तावेज़ से, रीड्यूसर के बारे में ज़्यादा जानें.

मास्क करना

ee.Image में मौजूद हर पिक्सल में वैल्यू और मास्क, दोनों होते हैं. इनकी रेंज 0 (कोई डेटा नहीं) से 1 तक होती है. मास्क किए गए पिक्सल (जिसमें mask==0) को कोई डेटा नहीं माना जाता. 0 < मास्क ≤ 1 वाले पिक्सल की वैल्यू होती है. हालांकि, संख्यात्मक गणना के लिए, मास्क के हिसाब से इसका वज़न तय किया जाता है.

मास्क का इस्तेमाल करके, पिक्सल को पारदर्शी बनाया जा सकता है या विश्लेषण से बाहर रखा जा सकता है. मास्क की वैल्यू शून्य होने पर, पिक्सल मास्क किए जाते हैं. इमेज के अंतर का उदाहरण जारी रखते हुए, अंतर के इंटरवल के दौरान एनडीवीआई में बढ़ोतरी और गिरावट वाले इलाकों को दिखाने के लिए मास्क का इस्तेमाल करें:

// This function gets NDVI from Landsat 5 imagery.
var getNDVI = function(image) {
  return image.normalizedDifference(['B4', 'B3']);
};

// Load two Landsat 5 images, 20 years apart.
var image1 = ee.Image('LANDSAT/LT05/C02/T1_TOA/LT05_044034_19900604');
var image2 = ee.Image('LANDSAT/LT05/C02/T1_TOA/LT05_044034_20100611');

// Compute NDVI from the scenes.
var ndvi1 = getNDVI(image1);
var ndvi2 = getNDVI(image2);

// Compute the difference in NDVI.
var ndviDifference = ndvi2.subtract(ndvi1);
// Load the land mask from the SRTM DEM.
var landMask = ee.Image('CGIAR/SRTM90_V4').mask();

// Update the NDVI difference mask with the land mask.
var maskedDifference = ndviDifference.updateMask(landMask);

// Display the masked result.
var vizParams = {min: -0.5, max: 0.5, palette: ['FF0000', 'FFFFFF', '0000FF']};
Map.setCenter(-122.2531, 37.6295, 9);
Map.addLayer(maskedDifference, vizParams, 'NDVI difference');

इस उदाहरण में, ध्यान दें कि एनडीवीआई के अंतर का मास्क, updateMask() के साथ लैंड मास्क से अपडेट किया गया है. यह एनडीवीआई के अंतर वाले पिक्सल के मास्क को लैंड मास्क पर सेट करता है. ऐसा तब किया जाता है, जब एनडीवीआई के अंतर वाला मास्क शून्य से अलग हो.

डेटा को विश्लेषण से बाहर रखने के लिए भी मास्किंग का इस्तेमाल किया जा सकता है. कम करने वाले सेक्शन में दिया गया reduceRegion() उदाहरण देखें. मान लें कि आपको कैलिफ़ोर्निया के सैंटा क्लारा काउंटी के लिए, सीज़न के हिसाब से औसत एनडीवीआई का हिसाब लगाना है. इसमें, बादल वाले पिक्सल को शामिल नहीं करना है. इस उदाहरण में कई कॉन्सेप्ट दिखाए गए हैं: फ़िल्टर करना, मैप करना, कम करना, और क्लाउड मास्क का इस्तेमाल करना:

// This function gets NDVI from a Landsat 8 image.
var addNDVI = function(image) {
  return image.addBands(image.normalizedDifference(['B5', 'B4']));
};

// This function masks cloudy pixels.
var cloudMask = function(image) {
  var clouds = ee.Algorithms.Landsat.simpleCloudScore(image).select(['cloud']);
  return image.updateMask(clouds.lt(10));
};

// Load a Landsat collection, map the NDVI and cloud masking functions over it.
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
  .filterBounds(ee.Geometry.Point([-122.262, 37.8719]))
  .filterDate('2014-03-01', '2014-05-31')
  .map(addNDVI)
  .map(cloudMask);

// Reduce the collection to the mean of each pixel and display.
var meanImage = collection.reduce(ee.Reducer.mean());
var vizParams = {bands: ['B5_mean', 'B4_mean', 'B3_mean'], min: 0.02, max: 0.4};
Map.addLayer(meanImage, vizParams, 'mean');

// Load a region in which to compute the mean and display it.
var counties = ee.FeatureCollection('TIGER/2018/Counties');
var santaClara = ee.Feature(counties.filter(ee.Filter.eq('NAME', 'Santa Clara')).first());
Map.addLayer(santaClara);

// Get the mean of NDVI in the region.
var mean = meanImage.select(['nd_mean']).reduceRegion({
  reducer: ee.Reducer.mean(),
  geometry: santaClara.geometry(),
  scale: 30
});

// Print mean NDVI for the region.
mean.get('nd_mean').evaluate(function(val){
  print('Santa Clara spring mean NDVI:', val);
});