Tutorial: Menggunakan API Microsoft Planetary Computer Pro untuk menyerap dan memvisualisasikan data

Koleksi STAC (Katalog Aset SpatioTemporal) digunakan dalam GeoCatalog untuk mengindeks dan menyimpan aset spatiotemporal terkait. Dalam tutorial end-to-end ini, Anda akan membuat koleksi STAC baru, menyerap gambar Sentinel-2 ke dalam koleksi, dan mengkueri gambar tersebut melalui API GeoCatalog.

Di tutorial ini, Anda akan:

Akan membuat koleksi STAC Anda sendiri dalam Planetary Computer Pro GeoCatalog
Serap citra satelit ke dalam koleksi itu dari Badan Antariksa Eropa
Konfigurasikan koleksi sehingga citra dalam koleksi dapat divisualisasikan di antarmuka web Planetary Computer Pro
Mengkueri data dari dalam koleksi STAC menggunakan API STAC Planetary Computer Pro

Tutorial ini menunjukkan dan menjelaskan kemampuan melalui cuplikan kode, untuk pengalaman gaya notebook interaktif, unduh tutorial ini sebagai notebook Jupyter.

Prasyarat

Sebelum menjalankan tutorial ini, Anda memerlukan Planetary Computer Pro GeoCatalog yang disebarkan di langganan Azure Anda. Anda juga memerlukan lingkungan untuk menjalankan notebook ini dan menginstal paket yang diperlukan. Sebaiknya jalankan tutorial ini melalui Azure Machine Learning Virtual Machine atau integrasi notebook Visual Studio Code di lingkungan virtual Python. Namun, notebook ini harus berjalan di mana pun Anda dapat menjalankan notebook Jupyter, asalkan persyaratan berikut terpenuhi:

Python 3.10 atau yang lebih baru
Azure CLI diinstal, dan Anda telah menjalankan az login untuk masuk ke akun Azure Anda
Persyaratan yang diperlukan yang tercantum di bagian Opsi Tutorial diinstal

Membuka notebook Jupyter di Azure Machine Learning atau Visual Studio Code

Masuk ke Azure dengan Azure CLI

Perintah berikut ini membuat Anda masuk ke Azure menggunakan Azure CLI. Jalankan perintah dan ikuti instruksi untuk masuk.

!az login

Pilih opsi tutorial

Sebelum menjalankan tutorial ini, Anda memerlukan akses kontributor ke instans GeoCatalog yang ada. Masukkan url instans GeoCatalog Anda dalam variabel geocatalog_url. Dalam tutorial ini, Anda akan membuat koleksi untuk citra Sentinel-2 yang disediakan oleh European Space Agency (ESA) yang saat ini disimpan di Katalog Data Komputer Planetary Microsoft.

# URL for your given GeoCatalog
geocatalog_url = (
    "<GEOCATALOG_URL>"
)
geocatalog_url = geocatalog_url.rstrip("/")  # Remove trailing slash if present

api_version = "2025-04-30-preview"

# User selections for demo

# Collection within the Planetary Computer
pc_collection = "sentinel-2-l2a"

# Bounding box for AOI
bbox_aoi = [-22.455626, 63.834083, -22.395201, 63.880750]

# Date range to search for imagery
param_date_range = "2024-02-04/2024-02-11"

# Maximum number of items to ingest
param_max_items = 6

Mengimpor paket yang diperlukan

Sebelum dapat membuat koleksi STAC, Anda perlu mengimpor beberapa paket python dan menentukan fungsi pembantu untuk mengambil token akses yang diperlukan.

pip install pystac-client azure-identity requests pillow

# Import the required packages
import json
import random
import string
import time
from datetime import datetime, timedelta, timezone
from io import BytesIO
from typing import Any, Optional, Dict

import requests
from azure.identity import AzureCliCredential
from IPython.display import Markdown as md
from IPython.display import clear_output
from PIL import Image
from pystac_client import Client

# Function to get a bearer token for the  Planetary Computer Pro API
MPC_APP_ID = "https://geocatalog.spatio.azure.com"

_access_token = None
def getBearerToken():
    global _access_token
    if not _access_token or datetime.fromtimestamp(_access_token.expires_on) < datetime.now() + timedelta(minutes=5):
        credential = AzureCliCredential()
        _access_token = credential.get_token(f"{MPC_APP_ID}/.default")

    return {"Authorization": f"Bearer {_access_token.token}"}

# Method to print error messages when checking response status
def raise_for_status(r: requests.Response) -> None:
    try:
        r.raise_for_status()
    except requests.exceptions.HTTPError as e:
        try:
            print(json.dumps(r.json(), indent=2))
        except:
            print(r.content)
        finally:
            raise

Membuat koleksi STAC

Mendefinisikan Koleksi STAC JSON

Selanjutnya, Anda menentukan koleksi STAC sebagai item JSON. Untuk tutorial ini, gunakan koleksi STAC JSON yang ada untuk koleksi Sentinel-2-l2a dalam Komputer Planetary Microsoft. Koleksi Anda diberi ID dan judul acak agar tidak bertentangan dengan koleksi lain yang ada.

# Load example STAC collection JSON

response = requests.get(
    f"https://planetarycomputer.microsoft.com/api/stac/v1/collections/{pc_collection}"
)
raise_for_status(response)
stac_collection = response.json()

collection_id = pc_collection + "-tutorial-" + str(random.randint(0, 1000))

# Genereate a unique name for the test collection
stac_collection["id"] = collection_id
stac_collection["title"] = collection_id

# Determine the storage account and container for the assets
pc_storage_account = stac_collection.pop("msft:storage_account")
pc_storage_container = stac_collection.pop("msft:container")
pc_collection_asset_container = (
    f"https://{pc_storage_account}.blob.core.windows.net/{pc_storage_container}"
)

# View your STAC collection JSON
stac_collection

Saat membuat koleksi dalam GeoCatalog, koleksi JSON tidak dapat memiliki aset tingkat koleksi apa pun (seperti gambar mini koleksi) yang terkait dengan koleksi, jadi pertama-tama hapus aset yang ada (jangan khawatir Anda menambahkan gambar mini kembali nanti).

# Save the thumbnail url
thumbnail_url = stac_collection['assets']['thumbnail']['href']

# Remove the assets field from the JSON (you'll see how to add this back later)
print("Removed the following items from the STAC Collection JSON:")
stac_collection.pop('assets')

# Create a STAC collection by posting to the STAC collections API

collections_endpoint = f"{geocatalog_url}/stac/collections"

response = requests.post(
    collections_endpoint,
    json=stac_collection,
    headers=getBearerToken(),
    params={"api-version": api_version}
)

if response.status_code==201:
    print("STAC Collection created named:",stac_collection['title'])
else:
    raise_for_status(response)

Buka antarmuka web GeoCatalog Anda dan Anda akan melihat koleksi baru Anda tercantum di bawah tab "Koleksi".

Gambar mini pengumpulan akses

Selanjutnya Anda ingin menambahkan gambar mini ke koleksi kami untuk ditampilkan bersama dengan koleksi kami. Untuk tujuan demo ini, gunakan gambar mini dari koleksi Sentinel-2 yang ada dalam Komputer Planeter Microsoft.

# Read thumbnail for your collection

thumbnail_response = requests.get(thumbnail_url)
raise_for_status(thumbnail_response)
img = Image.open(BytesIO(thumbnail_response.content))
img

Tambah gambar mini ke Planetary Computer Pro GeoCatalog Anda

Setelah membaca pratinjau, Anda dapat menambahkannya ke koleksi GeoCatalogs Anda dengan mempostingnya ke titik akhir API aset koleksi bersama dengan JSON aset yang diperlukan.

# Define the GeoCatalog collections API endpoint
collection_assets_endpoint = f"{geocatalog_url}/stac/collections/{collection_id}/assets"

# Read the example thumbnail from this collection from the Planetary Computer
thumbnail = {"file": ("lulc.png", thumbnail_response.content)}

# Define the STAC collection asset type - thumbnail in this case
asset = {
    "data": '{"key": "thumbnail", "href":"", "type": "image/png", '
    '"roles":  ["test_asset"], "title": "test_asset"}'
}

# Post the thumbnail to the GeoCatalog collections asset endpoint
response = requests.post(
    collection_assets_endpoint,
    data=asset,
    files=thumbnail,
    headers=getBearerToken(),
    params={"api-version": api_version}
)

if response.status_code==201:
    print("STAC Collection thumbnail updated for:",stac_collection['title'])
else:
    raise_for_status(response)

Baca koleksi baru dari dalam Planetary Computer Pro GeoCatalog Anda

Segarkan peramban Anda dan Anda akan dapat melihat gambar mini. Anda juga dapat mengambil koleksi JSON secara terprogram dengan melakukan panggilan berikut ke titik akhir koleksi:

# Request the collection JSON from your GeoCatalog
collection_endpoint = f"{geocatalog_url}/stac/collections/{stac_collection['id']}"

response = requests.get(
    collection_endpoint,
    json={'collection_id':stac_collection['id']},
    headers=getBearerToken(),
    params={"api-version": api_version}
)

if response.status_code==200:
    print("STAC Collection successfully read:",stac_collection['title'])
else:
    raise_for_status(response)

response.json()

print(f"""
You successfully created a new STAC Collection in GeoCatalog named {collection_id}.
You can view your collection by visiting the GeoCatalog Explorer: {geocatalog_url}/collections
""")

Mengimpor item & aset STAC

Setelah membuat koleksi ini, Anda siap untuk menyerap item STAC baru ke dalam koleksi STAC Anda menggunakan API Item GeoCatalog Anda! Selesaikan proses ini dengan:

Mendapatkan token SAS dari Komputer Planetary Microsoft
Mendaftarkan token tersebut sebagai Sumber Penyerapan dalam GeoCatalog
Posting Item STAC dari koleksi tersebut ke API Item GeoCatalog
Verifikasi bahwa Item berhasil diserap

ingestion_sources_endpoint = f"{geocatalog_url}/inma/ingestion-sources"
ingestion_source_endpoint = lambda id: f"{geocatalog_url}/inma/ingestion-sources/{id}"


def find_ingestion_source(container_url: str) -> Optional[Dict[str, Any]]:

    response = requests.get(
        ingestion_sources_endpoint,
        headers=getBearerToken(),
        params={"api-version": api_version},
    )

    for source in response.json()["value"]:
        ingestion_source_id = source["id"]

        response = requests.get(
            ingestion_source_endpoint(ingestion_source_id),
            headers=getBearerToken(),
            params={"api-version": api_version},
        )
        raise_for_status(response)

        response = response.json()

        if response["connectionInfo"]["containerUrl"] == container_url:
            return response


def create_ingestion_source(container_url: str, sas_token: str):
    response = requests.post(
        ingestion_sources_endpoint,
        json={
            "kind": "SasToken",
            "connectionInfo": {
                "containerUrl": container_url,
                "sasToken": sas_token,
            },
        },
        headers=getBearerToken(),
        params={"api-version": api_version},
    )
    raise_for_status(response)


def remove_ingestion_source(ingestion_source_id: str):
    response = requests.delete(
        ingestion_source_endpoint(ingestion_source_id),
        headers=getBearerToken(),
        params={"api-version": api_version},
    )
    raise_for_status(response)

Meminta informasi dari Komputer Planetari

Pertama, Anda perlu mengkueri Komputer Planet untuk mencari gambar Sentinel-2 yang sesuai dengan persyaratan spesifik kami. Dalam hal ini, Anda mencari citra Sentinel-2 di Planetary Computer yang cocok dengan kriteria berikut:

Koleksi - Citra dari koleksi Sentinel-2-l2a
Rentang waktu - Dikumpulkan antara 4 Februari dan 11 Februari 2024
Daerah yang diminati - Citra yang dikumpulkan di atas Islandia bagian selatan yang ditetapkan sebagai kotak pembatas

Dengan melakukan pencarian ini, Anda dapat melihat item STAC yang cocok ditemukan di dalam Komputer Planetary.

# Search criteria
print("Using the below parameters to search the Planetary Computer:\n")
print("Collection:", pc_collection)
print("Bounding box for area of interest:",bbox_aoi)
print("Date range:",param_date_range)
print("Max number of items:",param_max_items)

# Query the Planetary Computer

# Connect to the Planetary Computer
catalog = Client.open("https://planetarycomputer.microsoft.com/api/stac/v1")

search = catalog.search(collections=[pc_collection], bbox=bbox_aoi, datetime=param_date_range)
total_items = search.item_collection()

items = total_items[:param_max_items]
print("Total number of matching items:",len(total_items))
print("Total number of items for ingest base on user selected parameter:",len(items))

if total_items==0:
    print("No items matched your user specified parameters used at the top of this demo. Update these parameters")

# Print an example STAC item returned by the Planetary Computer
items[0]

Mendaftarkan sumber penyerapan

Sebelum Anda dapat menyerap item STAC ini dan aset terkaitnya (gambar) ke dalam koleksi GeoCatalog, Anda perlu menentukan apakah Anda perlu mendaftarkan sumber penyerapan baru. Sumber Penyerapan digunakan oleh GeoCatalog untuk melacak lokasi penyimpanan mana (kontainer Azure Blob Storage) yang dapat diaksesnya.

Mendaftarkan sumber penyerapan dilakukan dengan menyediakan GeoCatalog lokasi kontainer penyimpanan dan token SAS dengan izin baca untuk mengakses kontainer. Jika item STAC atau aset terkaitnya terletak di dalam kontainer penyimpanan dan GeoCatalog Anda belum diberi akses, maka proses pemasukan akan gagal.

Untuk memulai proses ini, Pertama-tama Anda meminta token SAS dari Planetary Computer yang memberi kami akses baca ke kontainer tempat gambar Sentinel-2 berada.

# Request API token from the Planetary Computer

pc_token = requests.get("https://planetarycomputer.microsoft.com/api/sas/v1/token/{}".format(pc_collection)).json()
print(f"Planetary Computer API Token will expire {pc_token['msft:expiry']}")

Upaya berikutnya untuk mendaftarkan kontainer Azure Blob Storage ini dan token SAS terkait sebagai sumber penyerapan dengan GeoCatalog. Ada potensi bahwa sumber penyerapan sudah ada untuk kontainer penyimpanan ini. Jika demikian, temukan ID sumber penyerapan yang ada.

Peringatan

Jika sumber penyerapan duplikat ditemukan dengan token yang kedaluwarsa dalam 15 menit ke depan, sumber tersebut akan dihapus dan diganti. Menghapus sumber penyerapan yang sedang digunakan dengan menjalankan penyerapan saat ini dapat merusak penyerapan tersebut.

existing_ingestion_source: Optional[Dict[str, Any]] = find_ingestion_source(pc_collection_asset_container)

if existing_ingestion_source:
    connection_info = existing_ingestion_source["connectionInfo"]
    expiration = datetime.fromisoformat(connection_info["expiration"].split('.')[0]) # works in all Python 3.X versions
    expiration = expiration.replace(tzinfo=timezone.utc) # set timezone to UTC
    if expiration < datetime.now(tz=timezone.utc) + timedelta(minutes=15):
        print(f"Recreating existing ingestion source for {pc_collection_asset_container}")
        remove_ingestion_source(existing_ingestion_source["id"])
        create_ingestion_source(pc_collection_asset_container, pc_token["token"])
    else:
        print(f"Using existing ingestion source for {pc_collection_asset_container} with expiration {expiration}")
else:
    print(f"Creating ingestion source for {pc_collection_asset_container}")
    create_ingestion_source(pc_collection_asset_container, pc_token["token"])

Memasukkan item STAC menggunakan API Items GeoCatalog

Sekarang setelah Anda mendaftarkan sumber penyerapan atau memvalidasi bahwa sumber ada, Anda akan menyerap item STAC yang Anda temukan dalam Komputer Planet menggunakan API Item GeoCatalog. Selesaikan ini dengan memposting setiap item ke API Item yang membuat operasi penyerapan baru dalam GeoCatalog.

# Ingest items

items_endpoint = f"{geocatalog_url}/stac/collections/{collection_id}/items"

operation_ids = []

for item in items:

    item_json = item.to_dict()
    item_json['collection'] = collection_id

    # Remove non-static assets
    del(item_json['assets']['rendered_preview'])
    del(item_json['assets']['preview'])
    del(item_json['assets']['tilejson'])

    response = requests.post(
        items_endpoint,
        json=item_json,
        headers=getBearerToken(),
        params={"api-version": api_version}
    )

    operation_ids.append(response.json()['id'])
    print(f"Ingesting item {item_json['id']} with operation id {response.json()['id']}")

Mengingat bahwa penyerapan item Sentinel-2 dapat memakan waktu sedikit, Anda dapat menjalankan kode ini untuk memeriksa status operasi penyerapan Anda menggunakan API Operasi GeoCatalog.

# Check the status of the operations
operations_endpoint = f"{geocatalog_url}/inma/operations"
# Loop through all the operations ids until the status of each operation ids is "Finished"
pending=True

start = time.time()

while pending:
    # Count the number of operation ids that are finished vs unfinished
    num_running = 0
    num_finished = 0
    num_failed = 0
    clear_output(wait=True)
    for operation_id in operation_ids:
        response = requests.get(
            f"{operations_endpoint}/{operation_id}",
            headers=getBearerToken(),
            params={"api-version": api_version},
        )
        raise_for_status(response)
        status = response.json()["status"]
        print(f"Operation id {operation_id} status: {status}")
        if status == "Running":
            num_running+=1
        elif status == "Failed":
            num_failed+=1
        elif status == "Succeeded":
            num_finished+=1
    
    num_running
    stop=time.time()
    # Print the sumary of num finished, num running and num failed
    
    print("Ingesting Imagery:")
    print(f"\tFinished: {num_finished}\n\tRunning: {num_running}\n\tFailed: {num_failed}")
    print("Time Elapsed (seconds):",str(stop-start))
    
    if num_running == 0:
        pending=False
        print(f"Ingestion Complete!\n\t{num_finished} items ingested.\n\t{num_failed} items failed.")

    else:
        print(f"Waiting for {num_running} operations to finish")
        time.sleep(5)

Anda dapat menyegarkan browser web Anda dan mengklik tab Item untuk melihat item yang baru diunggah ini.

Manajemen koleksi

Sekarang setelah Anda menyerap item STAC ini dan aset (gambar) terkait ke dalam koleksi STAC, Anda perlu menyediakan GeoCatalog Anda dengan beberapa file konfigurasi lainnya sebelum Anda dapat memvisualisasikan item ini di antarmuka web GeoCatalog.

Konfigurasi render koleksi

Pertama-tama unduh file konfigurasi render untuk koleksi ini dari Planetary Computer. File konfigurasi ini dapat dibaca oleh GeoCatalog untuk merender gambar dengan cara yang berbeda dalam Explorer. Ini karena item STAC mungkin berisi banyak aset (gambar) yang berbeda yang dapat digabungkan untuk membuat gambar yang sama sekali baru dari area tertentu yang menyoroti fitur yang terlihat atau tidak terlihat. Misalnya, item STAC Sentinel-2 memiliki lebih dari 12 gambar yang berbeda dari berbagai bagian spektrum elektromagnetik. Konfigurasi render ini menginstruksikan GeoCatalog tentang cara menggabungkan gambar-gambar ini sehingga dapat menampilkan gambar dalam Warna Alami atau Warna Palsu (Inframerah Warna).

# Read render JSON from Planetary Computer

render_json = requests.get("https://planetarycomputer.microsoft.com/api/data/v1/mosaic/info?collection={}".format(pc_collection)).json()
render_json['renderOptions']

Setelah membaca konfigurasi opsi render ini dari Komputer Planet, Anda dapat mengaktifkan opsi render ini untuk koleksi dengan memposting konfigurasi ini ke titik akhir opsi render.

# Post render options config to GeoCatalog render-options API

render_config_endpoint = f"{geocatalog_url}/stac/collections/{collection_id}/configurations/render-options"

for render_option in render_json['renderOptions']:

    # Rename render configs such that they can be stored by GeoCatalog
    render_option['id'] = render_option['name'].translate(str.maketrans('', '', string.punctuation)).lower().replace(" ","-")[:30]

    # Post render definition
    response = requests.post(
        render_config_endpoint,
        json=render_option,
        headers=getBearerToken(),
        params={"api-version": api_version}
    )

Definisi mosaik

Mirip dengan Konfigurasi Render yang dibahas di atas, Penjelajah GeoCatalog memungkinkan kami menentukan satu atau beberapa definisi mosaik untuk koleksi. Definisi mosaik ini memungkinkan kami untuk menginstruksikan Penjelajah GeoCatalog tentang cara memfilter item mana yang ditampilkan dalam Explorer. Misalnya, satu konfigurasi render dasar (ditunjukkan di sel berikutnya) menginstruksikan GeoCatalog untuk menampilkan gambar terbaru untuk area tertentu. Konfigurasi render yang lebih canggih memungkinkan kami merender tampilan yang berbeda seperti gambar yang paling tidak berawan untuk lokasi tertentu yang diambil pada Oktober 2023.

# Post mosaic definition

mosiacs_config_endpoint = f"{geocatalog_url}/stac/collections/{collection_id}/configurations/mosaics"

response = requests.post(
    mosiacs_config_endpoint,
    json={"id": "mos1",
          "name": "Most recent available",
          "description": "Most recent available imagery in this collection",
          "cql": []
    },
    headers=getBearerToken(),
    params={"api-version": api_version}
)

Buka antarmuka web GeoCatalog

Congrats! Anda membuat koleksi, menambahkan item dan aset STAC, dan memperbarui koleksi Anda untuk menyertakan file konfigurasi yang diperlukan sehingga dapat dilihat melalui Explorer dalam antarmuka web GeoCatalog.

Navigasi kembali ke Penjelajah GeoCatalog di antarmuka web untuk melihat koleksi Anda!

Pengumpulan kueri melalui API STAC

Setelah melihat koleksi Anda di Penjelajah GeoCatalog, Anda akan menelusuri cara menggunakan API STAC GeoCatalog untuk mencari dan mengambil item dan aset STAC untuk analisis lebih lanjut.

Proses ini dimulai dengan memposting pencarian ke API STAC GeoCatalog Anda. Secara khusus, Anda akan mencari citra dalam koleksi Anda yang termasuk dalam kotak pembatas asli yang Anda gunakan untuk mengekstrak citra dari Planetary Computer.

Tidak mengherankan kueri ini mengembalikan semua item STAC yang sebelumnya Anda tempatkan dalam koleksi Anda.

stac_search_endpoint = f"{geocatalog_url}/stac/search"

response = requests.post(
    stac_search_endpoint,
    json={"collections":[collection_id],
          "bbox":bbox_aoi
    },
    headers=getBearerToken(),
    params={"api-version": api_version, "sign": "true"}
)

matching_items = response.json()['features']
print(len(matching_items))

Di kueri sebelumnya, Anda juga menyediakan parameter lain: sign:true. Ini menginstruksikan GeoCatalog untuk mengembalikan href yang ditandatangani (item href + token SAS) yang memungkinkan Anda membaca aset yang diberikan dari Azure Blob Storage.

# Download one of the assets bands, band 09
asset_href = matching_items[0]['assets']['B09']['href']
print(asset_href)

response = requests.get(asset_href)
img = Image.open(BytesIO(response.content))
img

Membersihkan sumber daya

Hapus item

Pada titik ini, Anda telah membuat Koleksi GeoCatalog, menambahkan item dan aset ke koleksi, dan mengambil item dan aset tersebut menggunakan API STAC GeoCatalog. Untuk fase akhir tutorial ini, Anda akan menghapus item ini dan menghapus koleksi Anda.

# Delete all items

for item in matching_items:
    response = requests.delete(
        f"{items_endpoint}/{item['id']}",
        headers=getBearerToken(),
        params={"api-version": api_version}
    )

Anda dapat mengonfirmasi semua item Anda telah dihapus dengan menjalankan perintah berikutnya. Perhatikan bahwa mungkin perlu waktu satu atau dua menit untuk sepenuhnya menghapus item dan aset terkaitnya.

# Confirm that all the items have been deleted
response = requests.post(
    stac_search_endpoint,
    json={"collections":[stac_collection['id']],
          "bbox": bbox_aoi
    },
    headers=getBearerToken(),
    params={"api-version": api_version, "sign": "true"}
)

matching_items = response.json()['features']
print(len(matching_items))

Hapus koleksi

Sekarang sebagai langkah terakhir, Anda mungkin ingin menghapus koleksi Anda sepenuhnya dari instans GeoCatalog Anda.

# Delete the collection
response = requests.delete(
    f"{collections_endpoint}/{collection_id}",
    headers=getBearerToken(),
    params={"api-version": api_version}
)

raise_for_status(response)
print(f"STAC Collection deleted: {collection_id}")

Langkah selanjutnya

Membuat Koleksi STAC melalui antarmuka web

Dalam tutorial end-to-end ini, Anda menelusuri proses pembuatan koleksi STAC baru, menyerap gambar Sentinel-2 ke dalam koleksi, dan mengkueri gambar tersebut melalui API GeoCatalog. Jika Anda ingin mempelajari lebih lanjut tentang masing-masing topik ini, jelajahi materi lain ini:

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2025-05-20