इस गाइड में बताया गया है कि Google Colab का इस्तेमाल करके, Python से Earth Engine REST API को क्वेरी भेजने का तरीका क्या है. एपीआई को अन्य भाषाओं और एनवायरमेंट से ऐक्सेस करने के लिए भी यही सिद्धांत लागू होते हैं.
ध्यान दें: REST API में नई और बेहतर सुविधाएं शामिल हैं. ऐसा हो सकता है कि ये सभी उपयोगकर्ताओं के लिए सही न हों. अगर आपने Earth Engine का इस्तेमाल पहले कभी नहीं किया है, तो कृपया JavaScript गाइड पढ़ें.
Google Colab में चलाएं
GitHub पर सोर्स देखें
शुरू करने से पहले
इन निर्देशों का पालन करके:
- Earth Engine का ऐक्सेस कॉन्फ़िगर करना
- सेवा खाता बनाना
Colab notebook सेट अप करना
अगर आपको यह क्विकस्टार्ट शुरू से करना है, तो Colab के शुरुआती पेज पर जाकर, नई नोटबुक पर क्लिक करके एक नई Colab नोटबुक बनाएं. इसके बाद, नीचे दिए गए कोड के सैंपल को नई कोड सेल में डालें. Colab में Cloud SDK पहले से इंस्टॉल होता है. इसमें gcloud कमांड-लाइन टूल शामिल है. इसका इस्तेमाल Cloud सेवाओं को मैनेज करने के लिए किया जा सकता है. इसके अलावा, इस पेज की शुरुआत में मौजूद बटन से डेमो नोटबुक चलाएं.
Google Cloud में पुष्टि करना
सबसे पहले, आपको लॉगिन करना होगा, ताकि Google Cloud से पुष्टि किए गए अनुरोध किए जा सकें.
Colab में, ये काम किए जा सकते हैं:
PROJECT = 'my-project' !gcloud auth login --project {PROJECT}
(अगर आपको इसे स्थानीय तौर पर चलाना है, तो कमांड लाइन से चलाएं. इसके लिए, Cloud SDK इंस्टॉल होना चाहिए:)
PROJECT='my-project' gcloud auth login --project $PROJECT
अपने Google उपयोगकर्ता खाते का इस्तेमाल करके लॉग इन करने का विकल्प स्वीकार करें और साइन-इन की प्रोसेस पूरी करें.
अपने सेवा खाते के लिए निजी कुंजी फ़ाइल पाना
सेवा खाते का इस्तेमाल करके पुष्टि करने से पहले, आपको निजी कुंजी वाली फ़ाइल डाउनलोड करनी होगी. Colab में ऐसा करने के लिए, notebook VM में डाउनलोड करें:
SERVICE_ACCOUNT='foo-name@project-name.iam.gserviceaccount.com' KEY = 'my-secret-key.json' !gcloud iam service-accounts keys create {KEY} --iam-account {SERVICE_ACCOUNT}
इसके अलावा, कमांड लाइन से भी ऐसा किया जा सकता है:
SERVICE_ACCOUNT='foo-name@project-name.iam.gserviceaccount.com' KEY='my-secret-key.json' gcloud iam service-accounts keys create $KEY --iam-account $SERVICE_ACCOUNT
अपने क्रेडेंशियल ऐक्सेस करना और उनकी जांच करना
अब Earth Engine API को अपनी पहली क्वेरी भेजी जा सकती है. क्रेडेंशियल पाने के लिए, निजी पासकोड का इस्तेमाल करें. एचटीटीपी अनुरोध करने के लिए, क्रेडेंशियल का इस्तेमाल करके एक मान्य सेशन बनाएं. इसे अपनी Colab नोटबुक की नई कोड सेल में डाला जा सकता है. (अगर कमांड लाइन का इस्तेमाल किया जा रहा है, तो आपको यह पक्का करना होगा कि ज़रूरी लाइब्रेरी इंस्टॉल हों).
from google.auth.transport.requests import AuthorizedSession from google.oauth2 import service_account credentials = service_account.Credentials.from_service_account_file(KEY) scoped_credentials = credentials.with_scopes( ['https://www.googleapis.com/auth/cloud-platform']) session = AuthorizedSession(scoped_credentials) url = 'https://earthengine.googleapis.com/v1alpha/projects/earthengine-public/assets/LANDSAT' response = session.get(url) from pprint import pprint import json pprint(json.loads(response.content))
अगर सब कुछ सही तरीके से कॉन्फ़िगर किया गया है, तो इसे चलाने पर ऐसा आउटपुट मिलेगा:
{'id': 'LANDSAT',
'name': 'projects/earthengine-public/assets/LANDSAT',
'type': 'FOLDER'}
कोई डेटासेट चुनें
code.earthengine.google.com पर जाकर, Earth Engine Code Editor का इस्तेमाल करके, उपलब्ध डेटासेट खोजे और एक्सप्लोर किए जा सकते हैं. आइए, Sentinel 2 का कुछ डेटा खोजें. (अगर आपने Code Editor का इस्तेमाल पहले कभी नहीं किया है, तो साइन इन करने पर आपसे इसे Earth Engine को ऐक्सेस करने की अनुमति देने के लिए कहा जाएगा.) कोड एडिटर में, सबसे ऊपर मौजूद खोज बॉक्स में "sentinel" खोजें. कई रास्टर डेटासेट दिखते हैं:
"Sentinel-2: MultiSpectral Instrument (MSI), Level-1C" पर क्लिक करें:
इस तरह के डेटासेट के ब्यौरे वाले पेजों में, Earth Engine के सार्वजनिक डेटा कैटलॉग में मौजूद किसी भी डेटासेट का इस्तेमाल करने के लिए ज़रूरी जानकारी शामिल होती है. जैसे, डेटासेट का संक्षिप्त ब्यौरा, ज़्यादा जानकारी पाने के लिए डेटा उपलब्ध कराने वाली कंपनी के लिंक, डेटासेट पर लागू होने वाली इस्तेमाल से जुड़ी पाबंदियों के बारे में जानकारी, और डेटासेट का Earth Engine ऐसेट आईडी.
इस मामले में, हमें विंडो की दाईं ओर दिखता है कि यह इमेज कलेक्शन ऐसेट है. इसका पाथ COPERNICUS/S2 है.
किसी खास इमेज के लिए क्वेरी करना
इस Sentinel-2 डेटासेट में, 2015 से लेकर अब तक की दुनिया की 20 लाख से ज़्यादा इमेज शामिल हैं. आइए, इमेज कलेक्शन के लिए projects.assets.listImages क्वेरी जारी करें. इससे हमें अप्रैल 2017 का ऐसा डेटा मिलेगा जिसमें बादल कम हों. साथ ही, इसमें कैलिफ़ोर्निया के माउंटेन व्यू का कोई खास पॉइंट शामिल हो.
import urllib coords = [-122.085, 37.422] project = 'projects/earthengine-public' asset_id = 'COPERNICUS/S2' name = '{}/assets/{}'.format(project, asset_id) url = 'https://earthengine.googleapis.com/v1alpha/{}:listImages?{}'.format( name, urllib.parse.urlencode({ 'startTime': '2017-04-01T00:00:00.000Z', 'endTime': '2017-05-01T00:00:00.000Z', 'region': '{"type":"Point", "coordinates":' + str(coords) + '}', 'filter': 'CLOUDY_PIXEL_PERCENTAGE < 10', })) response = session.get(url) content = response.content for asset in json.loads(content)['images']: id = asset['id'] cloud_cover = asset['properties']['CLOUDY_PIXEL_PERCENTAGE'] print('%s : %s' % (id, cloud_cover))
यह स्क्रिप्ट, मिलती-जुलती इमेज के लिए कलेक्शन को क्वेरी करती है. साथ ही, JSON रिस्पॉन्स को डिकोड करती है. इसके बाद, मिलती-जुलती हर इमेज ऐसेट के लिए, ऐसेट आईडी और क्लाउड कवर प्रिंट करती है. आउटपुट ऐसा दिखना चाहिए:
COPERNICUS/S2/20170420T184921_20170420T190203_T10SEG : 4.3166
COPERNICUS/S2/20170430T190351_20170430T190351_T10SEG : 0
इस पॉइंट पर, इस महीने की दो ऐसी इमेज मौजूद हैं जिनमें बादल कम हैं.
किसी इमेज की जांच करना
ऐसा लगता है कि किसी एक इमेज में बादल नहीं हैं. आइए, उस ऐसेट पर करीब से नज़र डालें जिसका आईडी COPERNICUS/S2/20170430T190351_20170430T190351_T10SEG है. ध्यान दें कि सभी सार्वजनिक कैटलॉग ऐसेट, प्रोजेक्ट earthengine-public से जुड़ी होती हैं. यहां Python का एक स्निपेट दिया गया है. यह आईडी के हिसाब से किसी ऐसेट की जानकारी पाने के लिए, projects.assets.get क्वेरी जारी करेगा. साथ ही, उपलब्ध डेटा बैंड प्रिंट करेगा और पहले बैंड के बारे में ज़्यादा जानकारी प्रिंट करेगा:
asset_id = 'COPERNICUS/S2/20170430T190351_20170430T190351_T10SEG' name = '{}/assets/{}'.format(project, asset_id) url = 'https://earthengine.googleapis.com/v1alpha/{}'.format(name) response = session.get(url) content = response.content asset = json.loads(content) print('Band Names: %s' % ','.join(band['id'] for band in asset['bands'])) print('First Band: %s' % json.dumps(asset['bands'][0], indent=2, sort_keys=True))
आउटपुट कुछ ऐसा दिखना चाहिए:
Band Names: B1,B2,B3,B4,B5,B6,B7,B8,B8A,B9,B10,B11,B12,QA10,QA20,QA60
First Band: {
"dataType": {
"precision": "INTEGER",
"range": {
"max": 65535
}
},
"grid": {
"affineTransform": {
"scaleX": 60,
"scaleY": -60,
"translateX": 499980,
"translateY": 4200000
},
"crsCode": "EPSG:32610",
"dimensions": {
"height": 1830,
"width": 1830
}
},
"id": "B1",
"pyramidingPolicy": "MEAN"
}
डेटा बैंड की सूची, डेटासेट के ब्यौरे में पहले देखी गई सूची से मेल खाती है. हम देख सकते हैं कि इस डेटासेट में EPSG:32610 कोऑर्डिनेट सिस्टम या यूटीएम ज़ोन 10N में 16-बिट पूर्णांक डेटा है. इस पहले बैंड का आईडी B1 है और इसका रिज़ॉल्यूशन 60 मीटर प्रति पिक्सल है. इस निर्देशांक सिस्टम में इमेज का शुरुआती बिंदु, (499980,4200000) पर है.
affineTransform.scaleY की नेगेटिव वैल्यू से पता चलता है कि ओरिजन, इमेज के उत्तर-पश्चिम कोने में है. आम तौर पर ऐसा ही होता है: y पिक्सल इंडेक्स बढ़ने से, y स्पेशल कोऑर्डिनेट (दक्षिण की ओर) कम होते हैं.
Pixel की वैल्यू फ़ेच करना
आइए, इस इमेज के हाई रिज़ॉल्यूशन बैंड से कुछ डेटा पाने के लिए, projects.assets.getPixels क्वेरी जारी करें. डेटासेट की जानकारी वाले पेज पर बताया गया है कि बैंड B2, B3, B4, और B8 का रिज़ॉल्यूशन 10 मीटर प्रति पिक्सल है. यह स्क्रिप्ट, उन चार बैंड से डेटा की सबसे ऊपर बाईं ओर मौजूद 256x256 पिक्सल वाली टाइल को फ़ेच करती है. डेटा को numpy NPY फ़ॉर्मैट में लोड करने से, जवाब को Python डेटा ऐरे में डिकोड करना आसान हो जाता है.
import numpy import io name = '{}/assets/{}'.format(project, asset_id) url = 'https://earthengine.googleapis.com/v1alpha/{}:getPixels'.format(name) body = json.dumps({ 'fileFormat': 'NPY', 'bandIds': ['B2', 'B3', 'B4', 'B8'], 'grid': { 'affineTransform': { 'scaleX': 10, 'scaleY': -10, 'translateX': 499980, 'translateY': 4200000, }, 'dimensions': {'width': 256, 'height': 256}, }, }) pixels_response = session.post(url, body) pixels_content = pixels_response.content array = numpy.load(io.BytesIO(pixels_content)) print('Shape: %s' % (array.shape,)) print('Data:') print(array)
आउटपुट ऐसा दिखना चाहिए:
Shape: (256, 256)
Data:
[[( 899, 586, 351, 189) ( 918, 630, 501, 248) (1013, 773, 654, 378) ...,
(1014, 690, 419, 323) ( 942, 657, 424, 260) ( 987, 691, 431, 315)]
[( 902, 630, 541, 227) (1059, 866, 719, 429) (1195, 922, 626, 539) ...,
( 978, 659, 404, 287) ( 954, 672, 426, 279) ( 990, 678, 397, 304)]
[(1050, 855, 721, 419) (1257, 977, 635, 569) (1137, 770, 400, 435) ...,
( 972, 674, 421, 312) (1001, 688, 431, 311) (1004, 659, 378, 284)]
...,
[( 969, 672, 375, 275) ( 927, 680, 478, 294) (1018, 724, 455, 353) ...,
( 924, 659, 375, 232) ( 921, 664, 438, 273) ( 966, 737, 521, 306)]
[( 920, 645, 391, 248) ( 979, 728, 481, 327) ( 997, 708, 425, 324) ...,
( 927, 673, 387, 243) ( 927, 688, 459, 284) ( 962, 732, 509, 331)]
[( 978, 723, 449, 330) (1005, 712, 446, 314) ( 946, 667, 393, 269) ...,
( 949, 692, 413, 271) ( 927, 689, 472, 285) ( 966, 742, 516, 331)]]
अगर आपको इस इमेज से पिक्सल का कोई दूसरा सेट चुनना है, तो affineTransform में अपनी ज़रूरत के हिसाब से बदलाव करें. ध्यान रखें कि affineTransform को इमेज के स्पेशल कोऑर्डिनेट रेफ़रंस सिस्टम में तय किया जाता है. अगर आपको ओरिजन की जगह को पिक्सल कोऑर्डिनेट में बदलना है, तो इस आसान फ़ॉर्मूले का इस्तेमाल करें:
request_origin = image_origin + pixel_scale * offset_in_pixels
थंबनेल इमेज जनरेट करना
हम इस इमेज का आरजीबी थंबनेल जनरेट करने के लिए, इसी तरह के तरीके का इस्तेमाल कर सकते हैं. हम इमेज के ओरिजनल रिज़ॉल्यूशन में डेटा का अनुरोध करने के बजाय, किसी क्षेत्र और इमेज के डाइमेंशन के बारे में साफ़ तौर पर बताएंगे. पूरी इमेज का थंबनेल पाने के लिए, हम इमेज के फ़ुटप्रिंट की ज्यामिति को अनुरोध क्षेत्र के तौर पर इस्तेमाल कर सकते हैं. आखिर में, लाल, हरे, और नीले रंग के इमेज बैंड और डेटा वैल्यू की सही रेंज तय करके, हम आरजीबी थंबनेल इमेज पा सकते हैं.
इन सभी को एक साथ रखने पर, Python स्निपेट ऐसा दिखता है. इसमें Colab IPython इमेज डिसप्ले विजेट का इस्तेमाल किया गया है:
url = 'https://earthengine.googleapis.com/v1alpha/{}:getPixels'.format(name) body = json.dumps({ 'fileFormat': 'PNG', 'bandIds': ['B4', 'B3', 'B2'], 'region': asset['geometry'], 'grid': { 'dimensions': {'width': 256, 'height': 256}, }, 'visualizationOptions': { 'ranges': [{'min': 0, 'max': 3000}], }, }) image_response = session.post(url, body) image_content = image_response.content from IPython.display import Image Image(image_content)
यहां थंबनेल इमेज दी गई है:
