ลงทะเบียนชิ้นงาน Cloud Optimized GeoTIFF (COG)

Earth Engine รองรับชิ้นงานที่สนับสนุนโดย Cloud Optimized GeoTIFF (COG) ที่จัดเก็บไว้ใน Google Cloud Storage (GCS)

เมื่อคุณลงทะเบียนชิ้นงานที่ COG สนับสนุน Earth Engine จะจัดทำดัชนีช่องเชิงพื้นที่และข้อมูลเมตาของรูปภาพ ณ เวลาที่สร้าง ซึ่งจะทำให้รูปภาพมีประสิทธิภาพเมื่อใช้ในคอลเล็กชัน โดยมีประสิทธิภาพเทียบเท่ากับชิ้นงานที่นำเข้าแบบมาตรฐาน (ดูภาพรวมของ GeoTIFF (COG) ที่เพิ่มประสิทธิภาพสำหรับระบบคลาวด์)

คู่มือนี้ครอบคลุมการเตรียมไฟล์ การเขียนไฟล์ Manifest การส่งคำขอลงทะเบียน การกำหนดค่าสิทธิ์ และการอัปเดตหรือลบเนื้อหาที่ลงทะเบียน

ก่อนเริ่มต้น

ก่อนลงทะเบียน COG คุณต้องตั้งค่าทรัพยากร Cloud Storage ให้ถูกต้อง

ตำแหน่งที่ตั้งของที่เก็บข้อมูล

เพื่อให้ Earth Engine เข้าถึงที่เก็บข้อมูล Cloud Storage ได้ ที่เก็บข้อมูลต้องอยู่ในภูมิภาคหรือหลายภูมิภาคของศูนย์ข้อมูลต่อไปนี้

  • หลายภูมิภาค us
  • 2 ภูมิภาคในสหรัฐอเมริกาที่มี us-central1
  • ภูมิภาค us-central1

หากที่เก็บข้อมูลอยู่ในศูนย์ข้อมูลระดับภูมิภาคอื่นๆ (เช่น us-east4 หรือ europe-west1) Earth Engine จะปฏิเสธคำขอลงทะเบียนและคำขออ่าน ดูตำแหน่งที่ตั้งของที่เก็บข้อมูล Cloud Storage ที่รองรับ

คลาสพื้นที่เก็บข้อมูลและการเรียกเก็บเงิน

  • เราขอแนะนำให้ใช้คลาสพื้นที่เก็บข้อมูลมาตรฐาน พื้นที่เก็บข้อมูลมาตรฐานไม่มีกฎระยะเวลาการเก็บรักษาขั้นต่ำ ซึ่งจะช่วยป้องกันค่าปรับจากการลบก่อนกำหนดหากคุณอัปเดตหรือแทนที่ไฟล์ชั่วคราว
  • แม้ว่าลูปการคำนวณของ Earth Engine จะไม่ทำให้เกิดค่าบริการเพิ่มเติมสำหรับการดึงข้อมูลจาก Cloud Storage แต่การเข้าถึงระดับพื้นที่เก็บข้อมูลที่ไม่ใช่แบบพื้นที่เก็บข้อมูลมาตรฐานจากเครื่องมือภายนอก (เช่น ซอฟต์แวร์ GIS บนเดสก์ท็อป) จะทำให้เกิดค่าธรรมเนียมการดึงข้อมูลที่มีราคาสูง
  • คุณต้องเปิดใช้การเรียกเก็บเงินในโปรเจ็กต์ Google Cloud เพื่อใช้ Cloud Storage ดูคู่มือเริ่มต้นฉบับย่อของ Cloud Storage เพื่อเริ่มต้นใช้งาน

เตรียม COG

Earth Engine จะอ่าน COG จาก Cloud Storage โดยตรง โดยดึงข้อมูลเฉพาะส่วนหัวและไทล์ที่จำเป็นสำหรับการคำนวณ ดังนั้นเลย์เอาต์ของไฟล์จึงมีความสำคัญ TIFF ต้องมีลักษณะดังนี้

  • เรียงต่อกัน โดยมีขนาดไทล์เป็นเลขยกกำลัง 2 ของสี่เหลี่ยมจัตุรัสตั้งแต่ 16x16 ถึง 2048x2048 เราขอแนะนำให้ใช้ขนาด 512x512 เพื่อประสิทธิภาพที่ดีที่สุด
  • จัดเรียงให้ไดเรกทอรีไฟล์ภาพ (IFD) ทั้งหมดอยู่ที่จุดเริ่มต้น
  • รวมภาพรวมของเลขยกกำลัง 2 (หากมี) ภาพรวมไม่จำเป็น แต่เราขอแนะนำสำหรับรูปภาพที่มีขนาดใหญ่กว่าไทล์เดียว
  • ใช้การสลับ BAND หรือ PIXEL (ดูข้อดีข้อเสียได้ที่ไฟล์แบนด์เดียวเทียบกับไฟล์หลายแบนด์)

หากต้องการแปลงรูปภาพ ให้ใช้ไดรเวอร์ COG ของ GDAL ซึ่งจะสร้างเลย์เอาต์ที่จำเป็น (การปูกระเบื้อง ภาพรวม และตำแหน่งส่วนหัว) ในขั้นตอนเดียว เพิ่ม OVERVIEW_RESAMPLING=NEAREST สำหรับข้อมูลเชิงหมวดหมู่ โดยค่าเริ่มต้นคือ CUBIC ดูคำแนะนำเกี่ยวกับการบีบอัด ภาพรวม และเลย์เอาต์ได้ที่แนวทางปฏิบัติแนะนำสำหรับการเตรียม COG ภายนอก

GDAL 3.11+ CLI

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

Classic CLI

ละเว้น INTERLEAVE=BAND ใน GDAL เวอร์ชันที่เก่ากว่า 3.11

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

สร้างไฟล์ Manifest

ไม่ว่าคุณจะลงทะเบียน COG โดยใช้ไลบรารีของไคลเอ็นต์ Python ของ Earth Engine, เครื่องมือบรรทัดคำสั่ง earthengine หรือ REST API ของ Earth Engine คุณต้องกำหนดไฟล์ Manifest สำหรับการอัปโหลดรูปภาพที่ระบุปลายทางของเนื้อหา, URI ของ Cloud Storage และข้อมูลเมตาของแบนด์ (ไม่บังคับ) API และเครื่องมือบรรทัดคำสั่งจะอ้างอิงชิ้นงานที่ COG สนับสนุนเป็นรูปภาพภายนอก (ee.data.startExternalImageIngestion(), earthengine upload external_image, projects.image.importExternal)

ตัวอย่าง: COG รายการเดียวที่รองรับทุกแบนด์ หาก COG มีแบนด์ทั้งหมด (เช่น RGB) ไฟล์ Manifest จะต้องมีชุดไทล์เพียงชุดเดียว ดังนี้

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

ตัวอย่าง: COG หลายรายการ (1 รายการต่อแบนด์) หากคุณมีไฟล์แยกกันสำหรับแบนด์ต่างๆ (เช่น แดง เขียว และน้ำเงินในไฟล์แยกกัน) ให้ทำดังนี้

{
  "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 }
  ]
}

ข้อจำกัดของไฟล์ Manifest

ไฟล์ Manifest สำหรับเนื้อหาที่ COG สนับสนุนมีข้อจำกัดที่ไม่มีผลกับไฟล์ Manifest สำหรับการนำเข้าแบบมาตรฐาน ดังนี้

  • บักเก็ตเดียว: URI ทั้งหมดในไฟล์ Manifest ต้องอยู่ในบักเก็ต Cloud Storage เดียวกัน
  • URI 1 รายการต่อแหล่งที่มา: ImageSource แต่ละรายการต้องมี URI เพียง 1 รายการ คุณไม่สามารถโมเสกไฟล์หลายไฟล์เข้าด้วยกันเป็นแหล่งที่มาของชุดชิ้นส่วนเดียว หากต้องการโมเสกฉาก COG หลายฉาก ให้ลงทะเบียน COG แต่ละรายการเป็นชิ้นงานและรวมเป็น ee.ImageCollection โดยใช้ .mosaic()
  • No mask_bands: ไม่รองรับช่อง mask_bands ระดับบนสุด ใช้ missingData ในไฟล์ Manifest หรือตรวจสอบว่า TIFF มีค่า nodata ภายใน
  • ไม่มี data_type ในชุดไทล์: อย่าระบุ data_type ในส่วน tilesets เนื่องจากระบบจะตรวจหาโดยอัตโนมัติ
  • ไม่มี dimensions ในแหล่งที่มา: อย่าระบุ dimensions ใน ImageSource
  • เลขที่ subdataset_prefix / subdataset_suffix
  • ไม่มี min_tile_area_ratio หรือ skip_metadata_read

ส่งคำขอลงทะเบียน

คุณสามารถส่งไฟล์ Manifest ไปยัง Earth Engine โดยใช้ไลบรารีของไคลเอ็นต์ Python สำหรับ Earth Engine, เครื่องมือบรรทัดคำสั่ง earthengine หรือ REST API ของ Earth Engine เลือกวิธีที่เหมาะกับเวิร์กโฟลว์ของคุณมากที่สุด

ไลบรารีของไคลเอ็นต์ Python

ในสคริปต์ Python หรือ Jupyter Notebook ให้ใช้ไลบรารีของไคลเอ็นต์ 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 เป็นไฟล์ชื่อ 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 ที่ได้รับอนุญาตไปยังปลายทาง REST API ของ Earth Engine โดยตรง 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))

เมื่อส่งแล้ว คำขอลงทะเบียนจะเริ่มการดำเนินการจัดทำดัชนีข้อมูลเมตาแบบง่าย เนื่องจากการลงทะเบียน COG ไม่ได้คัดลอกข้อมูลพิกเซล การดำเนินการนี้จึงมักจะเสร็จสมบูรณ์ภายในไม่กี่วินาที

กำหนดค่าสิทธิ์

ข้อมูลพิกเซลของ COG จะยังคงอยู่ใน Cloud Storage ซึ่งแตกต่างจากชิ้นงาน Earth Engine มาตรฐาน เมื่อแชร์ชิ้นงานที่ COG สนับสนุนกับผู้อื่น คุณต้องให้สิทธิ์เข้าถึงระดับอ่านแก่บุคคลดังกล่าวทั้งในชิ้นงาน Earth Engine และไฟล์ Cloud Storage

ให้สิทธิ์เข้าถึงบักเก็ต Cloud Storage

ผู้ทำงานร่วมกันต้องมีสิทธิ์อ่านไฟล์จาก Cloud Storage

สิทธิ์ที่จำเป็น:

  • storage.buckets.get (เพื่อดึงข้อมูลเมตาและตำแหน่งของที่เก็บข้อมูล)
  • storage.objects.get (เพื่ออ่านข้อมูลพิกเซล)

คุณให้สิทธิ์เหล่านี้ได้โดยใช้บทบาท Cloud Storage มาตรฐานต่อไปนี้

  • ผู้มีสิทธิ์ดูที่เก็บข้อมูล (ให้สิทธิ์ storage.buckets.get ในการอ่านข้อมูลเมตาและตำแหน่งของที่เก็บข้อมูล)
  • Storage Object Viewer (ให้สิทธิ์ storage.objects.get ในการอ่านข้อมูลพิกเซล)

ขั้นตอนการกำหนดค่าในคอนโซล Google Cloud

  1. ไปที่เบราว์เซอร์ Cloud Storage
  2. คลิกชื่อที่เก็บข้อมูล
  3. เลือกแท็บสิทธิ์
  4. คลิกให้สิทธิ์เข้าถึง
  5. เพิ่มอีเมลของผู้ทำงานร่วมกัน (หรือกลุ่มใน Google Groups หรือ allUsers สำหรับการเข้าถึงแบบสาธารณะ)
  6. กำหนดบทบาทผู้มีสิทธิ์ดูบักเก็ตพื้นที่เก็บข้อมูลและผู้มีสิทธิ์ดูออบเจ็กต์พื้นที่เก็บข้อมูล
  7. คลิกบันทึก

แชร์ชิ้นงาน Earth Engine

แชร์ชิ้นงานโดยใช้เครื่องมือจัดการชิ้นงาน Earth Engine หรือ CLI ดูรายละเอียดได้ที่คู่มือการจัดการเนื้อหา

อัปเดต แทนที่ และลบชิ้นงานที่ COG สนับสนุน

ชิ้นงานที่ COG สนับสนุนคือตัวชี้ไปยังไฟล์เวอร์ชันที่เฉพาะเจาะจงใน Cloud Storage รวมถึงข้อมูลเมตา (รอยเท้า การฉายภาพ แบนด์ และเลย์เอาต์ภาพรวม) ที่ Earth Engine จัดทำดัชนีไว้เมื่อคุณลงทะเบียน Earth Engine จะปักหมุดเวอร์ชันไฟล์เพื่อให้ข้อมูลเมตานี้ไม่หลุดจากการซิงค์กับพิกเซล ซึ่งเป็นสิ่งที่ทำให้การอัปเดตชิ้นงานที่ COG สนับสนุนแตกต่างจากการอัปเดตชิ้นงานมาตรฐาน

การสร้างวัตถุ

เมื่อคุณลงทะเบียน COG แล้ว Earth Engine จะบันทึกรุ่น (หมายเลขเวอร์ชัน) ของออบเจ็กต์ Cloud Storage ควบคู่ไปกับ URI คุณจะเห็นการสร้างที่ปักหมุดไว้ในข้อมูลเมตาของออบเจ็กต์ โดยจะปรากฏเป็นคำต่อท้าย #<generation> ใน URI ดังนี้

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> ใน URI ของไฟล์ Manifest เมื่อลงทะเบียน (หรือลงทะเบียนซ้ำ) ชิ้นงาน หากไม่มี Earth Engine จะอ่านออบเจ็กต์ปัจจุบันและปักหมุดการสร้างที่พบ การปักหมุดอย่างชัดเจนมีประโยชน์สำหรับการย้อนกลับไปยังเวอร์ชันก่อนหน้าที่ที่เก็บข้อมูลที่มีการกำหนดเวอร์ชันออบเจ็กต์เก็บรักษาไว้

หากคุณเขียนทับไฟล์ใน Cloud Storage ไฟล์จะได้รับการสร้างใหม่ และหากคุณลบไฟล์ การสร้างที่ปักหมุดไว้จะหายไป ไม่ว่าในกรณีใด การอ่านพิกเซลของชิ้นงานจะล้มเหลว เว้นแต่ว่าการกำหนดเวอร์ชันออบเจ็กต์ในที่เก็บข้อมูลจะเก็บรักษาเจเนอเรชันเก่าไว้ ซึ่งในกรณีนี้ Earth Engine จะยังคงอ่านพิกเซลเก่าต่อไป การดำเนินการกับข้อมูลเมตาที่ใช้ระเบียนที่จัดทำดัชนี (เช่น ee.data.getAsset(), bandNames() และการกรองคอลเล็กชัน) จะยังคงทำงานต่อไปไม่ว่าจะด้วยวิธีใดก็ตาม

อัปเดตชิ้นงานหลังจากเปลี่ยนไฟล์

หากต้องการชี้ชิ้นงานที่มีอยู่ไปยังไฟล์เวอร์ชันใหม่ ให้ลงทะเบียนอีกครั้งโดยใช้ชื่อชิ้นงานเดียวกันและเปิดใช้การเขียนทับ Earth Engine จะอ่านส่วนหัว GeoTIFF อีกครั้ง จัดทำดัชนีข้อมูลเมตาอีกครั้ง และปักหมุดการสร้างใหม่ในการเรียกแบบซิงโครนัสครั้งเดียว ระบบจะคงสิทธิ์ที่มีอยู่ของเนื้อหาไว้ แต่พร็อพเพอร์ตี้ ช่วงเวลา และชื่อย่านความถี่จะมาจากไฟล์ Manifest ใหม่ ดังนั้นให้รวมทุกอย่างที่คุณตั้งค่าไว้ก่อนหน้านี้ด้วย ee.data.updateAsset()

  • Python: ee.data.startExternalImageIngestion(manifest, allow_overwrite=True)
  • บรรทัดคำสั่ง: earthengine upload external_image --force --manifest manifest.json
  • REST API: ใส่ "overwrite": true เป็นฟิลด์ระดับบนสุดควบคู่กับ "imageManifest" ในเนื้อหาคำขอ projects.image.importExternal

คุณไม่จำเป็นต้องลบชิ้นงานก่อน และการลบชิ้นงานจะส่งผลเสีย เนื่องจากชิ้นงานแบบสแตนด์อโลนจะสูญเสียสิทธิ์ และรูปภาพในคอลเล็กชันจะหายไปจากคอลเล็กชันชั่วคราว โปรดทราบว่า 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 จะจัดการเรื่องนี้ให้คุณ แต่จะลบทีละรายการ ดังนั้นคอลเล็กชันที่มีรูปภาพหลายหมื่นรูปอาจใช้เวลาหลายชั่วโมงในการนำออก

  • หากต้องการแทนที่รูปภาพของคอลเล็กชัน ให้เขียนทับแทนการลบ ลงทะเบียนรูปภาพแต่ละรูปอีกครั้งตามชื่อโดยเปิดใช้การเขียนทับ (ดูด้านบน) วิธีนี้จะส่งคำขอเพียง 1 รายการต่อรูปภาพแทนที่จะเป็น 2 รายการ ทำให้คอลเล็กชันมีข้อมูลอยู่ตลอด และหลีกเลี่ยงการลบและสร้างคอลเล็กชันขึ้นมาใหม่ ซึ่งเป็นที่ที่สิทธิ์ของคอลเล็กชันอยู่ ลบเฉพาะรูปภาพที่ไม่ได้อยู่ในชุดใหม่

  • หากต้องการลบเนื้อหาจำนวนมาก ให้ดำเนินการพร้อมกันจากสคริปต์ แสดงรายการเนื้อหาที่มี ee.data.listAssets() (โดยใช้มุมมอง BASIC ซึ่งจะแสดงเฉพาะชื่อและประเภทแทนข้อมูลเมตาแบบเต็มสำหรับรูปภาพทุกรูป) และลบออกจาก Thread Pool ขนาดเล็ก คำขอชิ้นงานจะใช้การจำกัดอัตราคำขอร่วมกันทั้งโปรเจ็กต์ ดังนั้นโปรดรักษาการทำงานพร้อมกันให้อยู่ในระดับที่เหมาะสม (ผู้ปฏิบัติงานประมาณ 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) และแมปกับรายการไฟล์ Manifest การส่ง allow_overwrite=True แม้ในการเรียกใช้ครั้งแรกจะทำให้กลุ่มปลอดภัยที่จะเรียกใช้อีกครั้งหลังจากเกิดความล้มเหลวบางส่วน เนื่องจากชิ้นงานที่สร้างขึ้นแล้วจะถูกแทนที่แทนที่จะทำให้เกิดข้อผิดพลาด

ใช้ชิ้นงานที่ลงทะเบียนไว้

เมื่อลงทะเบียนแล้ว คุณจะเข้าถึงชิ้นงานที่ COG สนับสนุนในสคริปต์ 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')

ดูคำตอบสำหรับคำถามที่พบบ่อยเกี่ยวกับสิทธิ์ การอัปเดตไฟล์ และการจัดการคอลเล็กชันขนาดใหญ่ได้ที่ส่วน COG ของคำถามที่พบบ่อย