Cloud Optimized GeoTIFF (COG) ऐसेट रजिस्टर करना

Earth Engine, Google Cloud Storage (GCS) में सेव की गई, Cloud Optimized GeoTIFFs (COGs) से बैकअप की गई ऐसेट के साथ काम करता है.

सीओजी-बैक्ड ऐसेट को रजिस्टर करने पर, Earth Engine ऐसेट बनाते समय इमेज के स्पेशल और मेटाडेटा फ़ील्ड को इंडेक्स करता है. इससे इमेज, कलेक्शन में इस्तेमाल किए जाने पर बेहतर परफ़ॉर्म करती है. इसकी परफ़ॉर्मेंस, स्टैंडर्ड तरीके से डाले गए ऐसेट की परफ़ॉर्मेंस से मिलती-जुलती होती है. ज़्यादा जानकारी के लिए, क्लाउड के लिए ऑप्टिमाइज़ किए गए GeoTIFF (सीओजी) की खास जानकारी देखें.

इस गाइड में, फ़ाइलें तैयार करने, मेनिफ़ेस्ट लिखने, रजिस्ट्रेशन का अनुरोध सबमिट करने, अनुमतियां कॉन्फ़िगर करने, और रजिस्टर की गई ऐसेट को अपडेट करने या मिटाने का तरीका बताया गया है.

शुरू करने से पहले

सीओजी को रजिस्टर करने से पहले, आपको अपने Cloud Storage संसाधनों को सही तरीके से सेट अप करना होगा.

बकेट की जगह

Earth Engine को आपकी Cloud Storage बकेट ऐक्सेस करने के लिए, बकेट को इनमें से किसी एक डेटा सेंटर क्षेत्र या एक से ज़्यादा क्षेत्रों में मौजूद होना चाहिए:

  • us मल्टी-रीजन
  • अमेरिका का कोई भी ड्यूअल-रीजन जिसमें us-central1 शामिल है
  • us-central1 क्षेत्र

अगर आपकी बकेट किसी अन्य रीजनल डेटा सेंटर (जैसे, us-east4 या europe-west1) में मौजूद है, तो Earth Engine, रजिस्ट्रेशन और डेटा को ऐक्सेस करने के अनुरोधों को अस्वीकार कर देगा. Cloud Storage बकेट के लिए इस्तेमाल की जा सकने वाली जगहें देखें.

स्टोरेज क्लास और बिलिंग

  • हमारा सुझाव है कि आप स्टैंडर्ड स्टोरेज क्लास का इस्तेमाल करें. स्टैंडर्ड स्टोरेज में, डेटा को कम से कम समय तक सेव रखने का कोई नियम नहीं होता. इसलिए, अगर कुछ समय के लिए सेव की गई फ़ाइलों को अपडेट किया जाता है या बदला जाता है, तो उन्हें समय से पहले मिटाने पर कोई जुर्माना नहीं लगता.
  • Earth Engine के कंप्यूटेशन लूप में, Cloud Storage से डेटा वापस पाने के लिए सरचार्ज नहीं लगता. हालांकि, डेस्कटॉप जीआईएस सॉफ़्टवेयर जैसे बाहरी टूल से नॉन-स्टैंडर्ड स्टोरेज टीयर को ऐक्सेस करने पर, डेटा वापस पाने के लिए ज़्यादा शुल्क देना पड़ता है.
  • Cloud Storage का इस्तेमाल करने के लिए, आपके Google Cloud प्रोजेक्ट पर बिलिंग की सुविधा चालू होनी चाहिए. शुरू करने के लिए, Cloud Storage की क्विकस्टार्ट गाइड देखें.

बेचे गए सामान की लागत (सीओजी) तैयार करना

Earth Engine, सीधे Cloud Storage से सीओजी को पढ़ता है. यह सिर्फ़ हेडर और उन टाइल को फ़ेच करता है जिनकी ज़रूरत किसी कंप्यूटेशन के लिए होती है. इसलिए, फ़ाइल का लेआउट मायने रखता है. TIFF फ़ाइल के लिए, यह ज़रूरी है कि:

  • टाइल वाला, जिसमें 16x16 से लेकर 2048x2048 तक के स्क्वेयर पावर-ऑफ़-2 टाइल डाइमेंशन हों. बेहतरीन परफ़ॉर्मेंस के लिए, हम 512x512 का सुझाव देते हैं.
  • इसे इस तरह से व्यवस्थित किया गया है कि सभी इमेज फ़ाइल डायरेक्ट्री (आईएफ़डी) शुरुआत में हों.
  • अगर कोई पावर-ऑफ़-2 ओवरव्यू है, तो उसे शामिल करें. ओवरव्यू ज़रूरी नहीं हैं. हालांकि, एक टाइल से बड़ी इमेज के लिए, ओवरव्यू देने का सुझाव दिया जाता है.
  • BAND या PIXEL इंटरलीव का इस्तेमाल करें. फ़ायदों और नुकसानों के बारे में जानने के लिए, सिंगल-बैंड बनाम मल्टी-बैंड फ़ाइलें देखें.

किसी इमेज को बदलने के लिए, GDAL के COG ड्राइवर का इस्तेमाल करें. यह ड्राइवर, एक ही चरण में ज़रूरी लेआउट (टाइलिंग, खास जानकारी, और हेडर प्लेसमेंट) बनाता है. कैटगरी में बांटे गए डेटा के लिए, OVERVIEW_RESAMPLING=NEAREST जोड़ें. डिफ़ॉल्ट रूप से, CUBIC का इस्तेमाल किया जाता है. कंप्रेशन, खास जानकारी, और लेआउट से जुड़े सुझावों के लिए, बाहरी सीओजी तैयार करने के सबसे सही तरीके देखें.

GDAL 3.11+ सीएलआई

gdal raster convert in.tif out.tif \
  -f COG \
  --co BIGTIFF=YES \
  --co BLOCKSIZE=512 \
  --co INTERLEAVE=BAND \
  --co OVERVIEWS=IGNORE_EXISTING \
  --co COMPRESS=ZSTD \
  --co LEVEL=16 \
  --co PREDICTOR=YES \
  --co NUM_THREADS=ALL_CPUS

क्लासिक सीएलआई

GDAL के 3.11 से पहले के वर्शन पर INTERLEAVE=BAND को शामिल न करें.

gdal_translate in.tif out.tif \
  -of COG \
  -co BIGTIFF=YES \
  -co BLOCKSIZE=512 \
  -co INTERLEAVE=BAND \
  -co OVERVIEWS=IGNORE_EXISTING \
  -co COMPRESS=ZSTD \
  -co LEVEL=16 \
  -co PREDICTOR=YES \
  -co NUM_THREADS=ALL_CPUS

मेनिफ़ेस्ट बनाना

चाहे आप Earth Engine Python क्लाइंट लाइब्रेरी, earthengine कमांड-लाइन टूल या Earth Engine REST API का इस्तेमाल करके सीओजी रजिस्टर करें, आपको इमेज अपलोड करने का मेनिफ़ेस्ट तय करना होगा. इसमें ऐसेट का डेस्टिनेशन, Cloud Storage यूआरआई, और वैकल्पिक बैंड मेटाडेटा की जानकारी देनी होगी. एपीआई और कमांड-लाइन टूल, सीओजी की मदद से काम करने वाली ऐसेट को बाहरी इमेज (ee.data.startExternalImageIngestion(), earthengine upload external_image, projects.image.importExternal) के तौर पर रेफ़र करते हैं.

उदाहरण: सभी बैंड के लिए एक ही सीओजी अगर आपके सीओजी में सभी बैंड (उदाहरण के लिए, आरजीबी) शामिल हैं, तो मेनिफ़ेस्ट में सिर्फ़ एक टाइलसेट की ज़रूरत होती है:

{
  "name": "projects/my-project/assets/my_cog_asset",
  "tilesets": [
    {
      "id": "default_tileset",
      "sources": [
        {
          "uris": [
            "gs://google-sample-bucket/my_optimized_image.tif"
          ]
        }
      ]
    }
  ]
}

उदाहरण: एक से ज़्यादा सीओजी (हर बैंड के लिए एक) अगर आपके पास अलग-अलग बैंड के लिए अलग-अलग फ़ाइलें हैं (उदाहरण के लिए, लाल, हरे, और नीले रंग के लिए अलग-अलग फ़ाइलें):

{
  "name": "projects/my-project/assets/my_multi_band_cog",
  "tilesets": [
    {
      "id": "red_tileset",
      "sources": [ { "uris": [ "gs://google-sample-bucket/band_red.tif" ] } ]
    },
    {
      "id": "green_tileset",
      "sources": [ { "uris": [ "gs://google-sample-bucket/band_green.tif" ] } ]
    }
  ],
  "bands": [
    { "id": "R", "tilesetId": "red_tileset", "tilesetBandIndex": 0 },
    { "id": "G", "tilesetId": "green_tileset", "tilesetBandIndex": 0 }
  ]
}

मेनिफ़ेस्ट से जुड़ी पाबंदियां

सीओजी-बैक्ड ऐसेट के मेनिफ़ेस्ट पर कुछ पाबंदियां लागू होती हैं. ये पाबंदियां, डेटा डालने के स्टैंडर्ड मेनिफ़ेस्ट पर लागू नहीं होतीं:

  • एक ही बकेट: मेनिफ़ेस्ट में मौजूद सभी यूआरआई, एक ही Cloud Storage बकेट में होने चाहिए.
  • हर सोर्स के लिए एक यूआरआई: हर ImageSource में सिर्फ़ एक यूआरआई होना चाहिए. एक से ज़्यादा फ़ाइलों को एक साथ मोज़ेक करके, एक टाइलसेट सोर्स में नहीं बदला जा सकता. एक से ज़्यादा सीओजी सीन को मोज़ेक करने के लिए, हर सीओजी को ऐसेट के तौर पर रजिस्टर करें. इसके बाद, .mosaic() का इस्तेमाल करके उन्हें ee.ImageCollection में जोड़ें.
  • No mask_bands: टॉप-लेवल mask_bands फ़ील्ड का इस्तेमाल नहीं किया जा सकता. मेनिफ़ेस्ट में missingData का इस्तेमाल करें या पक्का करें कि आपकी TIFF फ़ाइल में nodata की वैल्यू मौजूद हो.
  • टाइलसेट में data_type नहीं: tilesets सेक्शन में data_type की जानकारी न दें. इसका पता अपने-आप चल जाता है.
  • सोर्स में dimensions नहीं है: ImageSource में dimensions की जानकारी न दें.
  • नहीं subdataset_prefix / subdataset_suffix.
  • min_tile_area_ratio या skip_metadata_read नहीं.

रजिस्ट्रेशन का अनुरोध सबमिट करना

Earth Engine Python क्लाइंट लाइब्रेरी, earthengine कमांड-लाइन टूल या Earth Engine REST API का इस्तेमाल करके, Earth Engine में अपना मेनिफ़ेस्ट सबमिट किया जा सकता है. वह तरीका चुनें जो आपके वर्कफ़्लो के लिए सबसे सही हो.

Python क्लाइंट लाइब्रेरी

Python स्क्रिप्ट या Jupyter नोटबुक में, अपने प्रोजेक्ट को शुरू करने के बाद, Earth Engine Python क्लाइंट लाइब्रेरी (ee.data) का इस्तेमाल करें:

import ee

# 1. Authenticate and initialize
ee.Authenticate()
ee.Initialize(project='your-project-id')

# 2. Define the manifest as a Python dictionary
manifest = {
  "name": "projects/your-project-id/assets/my_cog_asset",
  "tilesets": [
    {
      "id": "default_tileset",
      "sources": [
        {
          "uris": [
            "gs://google-sample-bucket/my_optimized_image.tif"
          ]
        }
      ]
    }
  ]
}

# 3. Register the asset
result = ee.data.startExternalImageIngestion(manifest)
print(f"Asset registered: {result['name']}")

कमांड-लाइन टूल

अपने टर्मिनल में, मेनिफ़ेस्ट को manifest.json नाम की फ़ाइल में सेव करें और earthengine अपलोड करने का निर्देश चलाएं:

# 1. Verify your environment is authenticated
earthengine authenticate

# 2. Register the asset
earthengine --project your-project-id \
  upload external_image \
  --manifest manifest.json

REST API

क्लाइंट लाइब्रेरी के बिना ऑटोमेटेड वर्कफ़्लो के लिए, अनुमति वाला POST अनुरोध सीधे Earth Engine REST API एंडपॉइंट projects.image.importExternal पर भेजें. यहां Python का इस्तेमाल करके इसे दिखाया गया है:

import json
from pprint import pprint
import ee
from google.auth.transport.requests import AuthorizedSession

# 1. Authenticate and start an authorized HTTP session
ee.Authenticate()
ee_project = 'your-project-id'
session = AuthorizedSession(
    ee.data.get_persistent_credentials().with_quota_project(ee_project)
)

# 2. Define the REST request body wrapping the manifest
request = {
  'imageManifest': {
    'name': f'projects/{ee_project}/assets/my_cog_asset',
    'tilesets': [
      {
        'id': 'default_tileset',
        'sources': [
          {
            'uris': [
              'gs://google-sample-bucket/my_optimized_image.tif'
            ]
          }
        ]
      }
    ]
  }
}

# 3. Send the POST request
url = (
    'https://earthengine.googleapis.com/v1alpha/'
    f'projects/{ee_project}/image:importExternal'
)
response = session.post(url=url, data=json.dumps(request))
pprint(json.loads(response.content))

अनुरोध सबमिट करने के बाद, मेटाडेटा को इंडेक्स करने की प्रोसेस शुरू हो जाती है. सीओजी रजिस्ट्रेशन में पिक्सल डेटा कॉपी नहीं होता है. इसलिए, यह प्रोसेस आम तौर पर कुछ ही सेकंड में पूरी हो जाती है.

अनुमतियां कॉन्फ़िगर करें

Earth Engine की स्टैंडर्ड ऐसेट के उलट, सीओजी का पिक्सल डेटा Cloud Storage में सेव रहता है. सीओजी पर आधारित एसेट को दूसरों के साथ शेयर करते समय, आपको उन्हें Earth Engine एसेट और Cloud Storage फ़ाइलों, दोनों को पढ़ने का ऐक्सेस देना होगा.

Cloud Storage बकेट की अनुमतियां देना

साथ मिलकर काम करने वाले लोगों के पास, Cloud Storage से फ़ाइलें पढ़ने की अनुमतियां होनी चाहिए.

ज़रूरी अनुमतियां:

  • storage.buckets.get (बकेट मेटाडेटा और जगह की जानकारी पाने के लिए)
  • storage.objects.get (पिक्सल डेटा पढ़ने के लिए)

Cloud Storage की इन स्टैंडर्ड भूमिकाओं का इस्तेमाल करके, ये अनुमतियां दी जा सकती हैं:

  • स्टोरेज बकेट व्यूअर (यह बकेट के मेटाडेटा और जगह की जानकारी को पढ़ने के लिए, storage.buckets.get की अनुमति देता है)
  • स्टोरेज ऑब्जेक्ट व्यूअर (पिक्सल डेटा को पढ़ने के लिए storage.objects.get देता है)

Google Cloud Console में कॉन्फ़िगर करने का तरीका:

  1. Cloud Storage ब्राउज़र पर जाएं.
  2. अपनी बकेट के नाम पर क्लिक करें.
  3. अनुमतियां टैब को चुनें.
  4. ऐक्सेस दें पर क्लिक करें.
  5. अपने सहयोगियों के ईमेल पते जोड़ें. इसके अलावा, कोई Google ग्रुप या सार्वजनिक ऐक्सेस के लिए allUsers जोड़ें.
  6. स्टोरेज बकेट व्यूअर और स्टोरेज ऑब्जेक्ट व्यूअर की भूमिकाएं असाइन करें.
  7. सेव करें पर क्लिक करें.

Earth Engine ऐसेट शेयर करना

Earth Engine Asset Manager या सीएलआई का इस्तेमाल करके, एसेट को शेयर करें. ज़्यादा जानकारी के लिए, ऐसेट मैनेजमेंट गाइड देखें.

सीओजी की मदद से जनरेट की गई ऐसेट को अपडेट करना, बदलना, और मिटाना

सीओजी-बैक्ड ऐसेट, Cloud Storage में मौजूद किसी फ़ाइल के खास वर्शन का पॉइंटर होती है. साथ ही, इसमें मेटाडेटा (फ़ुटप्रिंट, प्रोजेक्शन, बैंड, और खास जानकारी वाला लेआउट) भी शामिल होता है. इसे Earth Engine ने तब इंडेक्स किया था, जब आपने इसे रजिस्टर किया था. Earth Engine, फ़ाइल के वर्शन को पिन करता है, ताकि यह मेटाडेटा पिक्सल के साथ सिंक से बाहर न हो जाए. इस वजह से, सीओजी की मदद से काम करने वाली ऐसेट को अपडेट करना, स्टैंडर्ड ऐसेट को अपडेट करने से अलग होता है.

ऑब्जेक्ट जनरेशन

जब कोई सीओजी रजिस्टर किया जाता है, तो Earth Engine, यूआरआई के साथ-साथ Cloud Storage ऑब्जेक्ट के जनरेशन (इसका वर्शन नंबर) को रिकॉर्ड करता है. पिन किए गए जनरेशन को ऐसेट के मेटाडेटा में देखा जा सकता है. यह यूआरआई पर #<generation> सफ़िक्स के तौर पर दिखता है:

Python

asset = ee.data.getAsset('projects/your-project-id/assets/my_cog_asset')
print(asset['tilesets'][0]['sources'][0]['uris'])
# ['gs://google-sample-bucket/my_optimized_image.tif#1750427474244728']

एसेट को रजिस्टर (या फिर से रजिस्टर) करते समय, मेनिफ़ेस्ट यूआरआई में #<generation> सफ़िक्स शामिल करके, किसी खास वर्शन को खुद भी पिन किया जा सकता है. इसके बिना, Earth Engine मौजूदा ऑब्जेक्ट को पढ़ता है और उसे जो भी जनरेशन मिलती है उसे पिन कर देता है. किसी वर्शन को पिन करने से, पिछले वर्शन पर वापस जाने में मदद मिलती है. यह वर्शन, ऑब्जेक्ट के वर्शन वाली बकेट में सेव रहता है.

अगर Cloud Storage में मौजूद फ़ाइल को ओवरराइट किया जाता है, तो उसे एक नया जनरेशन नंबर मिलता है. साथ ही, अगर उसे मिटाया जाता है, तो पिन किया गया जनरेशन नंबर हट जाता है. दोनों ही मामलों में, ऐसेट के पिक्सल को रीड नहीं किया जा सकता. हालांकि, अगर बकेट पर ऑब्जेक्ट का वर्शन पुरानी जनरेशन को बनाए रखता है, तो Earth Engine पुराने पिक्सल को रीड करता रहेगा. इंडेक्स किए गए रिकॉर्ड का इस्तेमाल करने वाले मेटाडेटा ऑपरेशन, दोनों ही तरीकों से काम करते हैं. जैसे, ee.data.getAsset(), bandNames(), और कलेक्शन फ़िल्टर करना.

किसी ऐसेट की फ़ाइल बदलने के बाद, उसे अपडेट करना

किसी मौजूदा ऐसेट को उसकी फ़ाइल के नए वर्शन पर ले जाने के लिए, उसे उसी ऐसेट के नाम के साथ फिर से रजिस्टर करें और ओवरराइट करने की सुविधा चालू करें. Earth Engine, GeoTIFF हेडर को फिर से पढ़ता है, मेटाडेटा को फिर से इंडेक्स करता है, और नई जनरेशन को पिन करता है. यह सब एक ही सिंक्रोनस कॉल में होता है. ऐसेट की मौजूदा अनुमतियां सुरक्षित रखी जाती हैं. हालांकि, इसकी प्रॉपर्टी, समयसीमा, और बैंड के नाम नए मेनिफ़ेस्ट से आते हैं. इसलिए, इसमें वह सब कुछ शामिल करें जो आपने पहले ee.data.updateAsset() के साथ सेट किया था.

  • Python: ee.data.startExternalImageIngestion(manifest, allow_overwrite=True)
  • कमांड लाइन: earthengine upload external_image --force --manifest manifest.json
  • REST API: projects.image.importExternal अनुरोध के मुख्य हिस्से में, "overwrite": true को "imageManifest" के साथ टॉप-लेवल फ़ील्ड के तौर पर शामिल करें.

आपको पहले ऐसेट को मिटाने की ज़रूरत नहीं है. ऐसा करने से, आपको नुकसान हो सकता है: अलग से मौजूद ऐसेट की अनुमतियां हट जाती हैं और कलेक्शन में मौजूद इमेज, कुछ समय के लिए कलेक्शन से गायब हो जाती है. ध्यान दें कि ee.data.updateAsset() (projects.assets.patch) सिर्फ़ प्रॉपर्टी, समयसीमा, और बैंड के नाम बदल सकता है. यह उस फ़ाइल को नहीं बदल सकता जिस पर कोई ऐसेट ले जाती है.

अलग-अलग लाइफ़साइकल

Earth Engine ऐसेट और Cloud Storage ऑब्जेक्ट को अलग-अलग मैनेज किया जाता है:

  • Earth Engine ऐसेट (earthengine rm या ee.data.deleteAsset()) को मिटाने से, सिर्फ़ ऐसेट का रिकॉर्ड मिटता है. Cloud Storage में मौजूद आपकी फ़ाइलों में कोई बदलाव नहीं किया गया है.
  • Cloud Storage में मौजूद फ़ाइल को मिटाने से, ऐसेट नहीं हटती. यह अब भी लिस्टिंग और कलेक्शन में दिखती है. ऑब्जेक्ट जनरेशन देखें.

बड़े कलेक्शन के साथ काम करना

Earth Engine API में, एक साथ कई ऐसेट या रिकर्सिव तरीके से ऐसेट मिटाने की सुविधा नहीं है: हर ऐसेट को अलग से मिटाना होगा. साथ ही, किसी कलेक्शन को मिटाने से पहले, उसे खाली करना होगा. earthengine rm -r आपके लिए यह काम करता है. हालांकि, यह एक बार में एक ही इमेज मिटाता है. इसलिए, हज़ारों इमेज वाले कलेक्शन को हटाने में घंटों लग सकते हैं.

  • किसी कलेक्शन की इमेज बदलने के लिए, उन्हें मिटाने के बजाय ओवरराइट करें. हर इमेज को उसके नाम से फिर से रजिस्टर करें. इसके लिए, ओवरराइट करने की सुविधा चालू करें (ऊपर देखें). इसके लिए, हर इमेज के लिए दो के बजाय एक अनुरोध की ज़रूरत होती है. इससे कलेक्शन में हमेशा इमेज मौजूद रहती हैं. साथ ही, कलेक्शन को मिटाने और फिर से बनाने की ज़रूरत नहीं पड़ती. कलेक्शन को मिटाने पर, उसकी अनुमतियां भी मिट जाती हैं. सिर्फ़ उन इमेज को मिटाएं जो नए सेट में नहीं हैं.
  • कई ऐसेट मिटाने के लिए, स्क्रिप्ट का इस्तेमाल करके एक साथ कई ऐसेट मिटाएं. ee.data.listAssets() के साथ ऐसेट की सूची बनाएं (BASIC व्यू का इस्तेमाल करके, जो हर इमेज के लिए पूरा मेटाडेटा देने के बजाय सिर्फ़ नाम और टाइप दिखाता है) और उन्हें छोटे थ्रेड पूल से मिटाएं. ऐसेट के अनुरोध, पूरे प्रोजेक्ट के लिए तय की गई अनुरोध संख्या सीमित करना शेयर करते हैं. इसलिए, एक साथ कई अनुरोध भेजने की संख्या को कम रखें (करीब 10 वर्कर) और क्लाइंट लाइब्रेरी के पहले से मौजूद फिर से कोशिश करने की सुविधा को किसी भी 429 Too Many Requests रिस्पॉन्स को हैंडल करने दें:

    Python

    import concurrent.futures
    import ee
    
    ee.Initialize(project='your-project-id')
    collection = 'projects/your-project-id/assets/my_collection'
    
    listing = ee.data.listAssets({'parent': collection, 'view': 'BASIC'})
    asset_ids = [a['name'] for a in listing['assets']]
    
    def delete(asset_id):
      try:
        ee.data.deleteAsset(asset_id)
      except ee.EEException as e:
        return f'{asset_id}: {e}'
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
      failures = [f for f in executor.map(delete, asset_ids) if f]
    
    if failures:
      print('\n'.join(failures))
    else:
      ee.data.deleteAsset(collection)
    

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

    कई इमेज रजिस्टर करने के लिए भी यही पैटर्न लागू होता है: हेल्पर में ee.data.deleteAsset(asset_id) को ee.data.startExternalImageIngestion(manifest, allow_overwrite=True) से बदलें और इसे मेनिफ़ेस्ट की सूची में मैप करें. पहली बार चलाने पर भी allow_overwrite=True को पास करने से, बैच को आंशिक रूप से विफल होने के बाद फिर से चलाना सुरक्षित हो जाता है. ऐसा इसलिए, क्योंकि पहले से बनाई गई किसी भी ऐसेट को गड़बड़ी की वजह बनने के बजाय बदल दिया जाता है.

रजिस्टर की गई ऐसेट का इस्तेमाल करना

रजिस्टर होने के बाद, सीओजी की मदद से बनाई गई ऐसेट को Earth Engine स्क्रिप्ट में ऐक्सेस किया जा सकता है. ठीक वैसे ही जैसे, सिस्टम में शामिल की गई किसी स्टैंडर्ड इमेज ऐसेट को ऐक्सेस किया जाता है:

JavaScript

var image = ee.Image('projects/your-project-id/assets/my_cog_asset');

Python

image = ee.Image('projects/your-project-id/assets/my_cog_asset')

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