Oktatóanyag: Adatok betöltése és vizualizációja a Microsoft Planetary Computer Pro API-kkal

A STAC (SpatioTemporal Asset Catalog) gyűjtemények a GeoCatalogban a kapcsolódó spatiotemporális objektumok indexelésére és tárolására szolgálnak. Ebben az átfogó oktatóanyagban létrehoz egy új STAC-gyűjteményt, a Sentinel-2 műholdképeket a gyűjteménybe történő betöltésével, és a GeoCatalog API-ján keresztül lekérdezi ezeket a képeket.

Ebben az útmutatóban Ön:

  • Létrehoz egy saját STAC-gyűjteményt egy Planetary Computer Pro GeoCatalogon belül
  • Műholdképek betöltése ebbe a gyűjteménybe az Európai Űrügynökségtől
  • Konfigurálja a gyűjteményt, hogy a gyűjteményben lévő képek megjeleníthetők legyenek a Planetary Computer Pro webes felületén
  • Adatok lekérdezése a STAC-gyűjteményből a Planetary Computer Pro STAC API-jával

Ez az oktatóanyag kódrészleteken keresztül mutatja be és ismerteti a képességeket. Az interaktív jegyzetfüzetstílus használatához töltse le ezt az oktatóanyagot Jupyter-jegyzetfüzetként.

Tip

Ez az oktatóanyag a REST API megközelítését mutatja be. A Planetary Computer Pro Python SDK (pip install azure-planetarycomputer) is használható az egyszerűsített ügyfélélményhez. Az SDK-példákhoz tekintse meg az egyes rövid útmutatókat:

Előfeltételek

Az oktatóanyag futtatása előtt üzembe kell helyeznie egy Planetary Computer Pro GeoCatalogot az Azure-előfizetésében. A jegyzetfüzet végrehajtásához és a szükséges csomagok telepítéséhez egy környezetre is szükség van. Javasoljuk, hogy futtassa ezt az oktatóanyagot egy Azure Machine Learning virtuális gépen vagy a Visual Studio Code notebook integrációját használva egy Python virtuális környezetben. Ennek a jegyzetfüzetnek azonban mindenhol futnia kell, ahol a Jupyter-jegyzetfüzeteket futtathatja, feltéve, hogy a következő követelmények teljesülnek:

  • Python 3.10 vagy újabb
  • Az Azure CLI telepítve van, és az 'az login' parancs futtatásával bejelentkezett az Azure-fiókjába.
  • Az Oktatóanyag beállításai szakaszban felsorolt szükséges követelmények telepítve vannak

Jupyter-jegyzetfüzet megnyitása az Azure Machine Learningben vagy a VS Code-ban

Jelentkezzen be az Azure-ba az Azure CLI használatával

Az alábbi parancs az Azure CLI használatával jelentkezik be az Azure-ba. Futtassa a parancsot, és kövesse az utasításokat a bejelentkezéshez.

!az login

Oktatóanyag beállításainak kiválasztása

Az oktatóanyag futtatása előtt közreműködői hozzáférésre van szüksége egy meglévő GeoCatalog-példányhoz. Adja meg a GeoCatalog-példány URL-címét a geocatalog_url változóban. Ebben az oktatóanyagban létrehoz egy gyűjteményt a Sentinel-2 rendszerképekhez, amelyeket az Európai Űrügynökség (ESA) biztosít, amely jelenleg a Microsoft planetáris számítógépes adatkatalógusában van tárolva.

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

api_version = "2026-04-15"

# 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

A szükséges csomagok importálása

A STAC-gyűjtemény létrehozása előtt importálnia kell néhány Python-csomagot, és meg kell határoznia a segédfüggvényeket a szükséges hozzáférési jogkivonat lekéréséhez.

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

STAC-gyűjtemény létrehozása

STAC-gyűjtemény JSON-ének definiálása

Ezután egy STAC-gyűjteményt JSON-elemként definiál. Ebben az oktatóanyagban használjon egy meglévő JSON-beli STAC-gyűjteményt a Sentinel-2-l2a gyűjteményhez a Microsoft planetáris számítógépén. A gyűjtemény véletlenszerű azonosítót és címet kap, hogy ne ütközjön más meglévő gyűjteményekkel.

# 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))

# Generate 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

Ha gyűjteményt hoz létre a GeoCatalogon belül, a JSON-gyűjtemény nem rendelkezhet gyűjteményszintű eszközökkel (például gyűjteményminiatűrrel) a gyűjteményhez, ezért először távolítsa el a meglévő objektumokat (ne aggódjon, hogy később hozzáadja a miniatűrt).

# 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)

Nyissa meg a GeoCatalog webes felületét, és az új gyűjteménynek a Gyűjtemények lapon kell megjelennie.

Gyűjtemény miniatűrjének elérése

Ezután bélyegképet szeretne hozzáadni a gyűjteményünkhöz, hogy az a gyűjteményünkkel együtt megjelenjen. A bemutató céljaira használja a Microsoft Planetary Computer meglévő Sentinel-2 gyűjteményének miniatűrjét.

# Read thumbnail for your collection

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

Miniatűr hozzáadása a Planetary Computer Pro GeoCataloghoz

Miután megtekintette a miniatűrt, hozzáadhatja a gyűjteményünkhöz, úgy hogy közzéteszi a GeoCatalogs gyűjtemény API-végpontjára, a szükséges json objektummal együtt.

# 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)

Olvassa el az új gyűjteményt a Planetary Computer Pro GeoCatalogból

Frissítse a böngészőt, és látnia kell a miniatűrt. A gyűjtemény JSON-kódját programozott módon is lekérheti a gyűjtemény végpontjának következő hívásával:

# 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
""")

STAC-elemek & objektumok betöltése

A gyűjtemény létrehozása után készen áll arra, hogy új STAC-elemeket vegyen fel a STAC-gyűjteménybe a GeoCatalog Items API használatával! Ezt a folyamatot a következő módon hajtja végre:

  1. SAS-jogkivonat beszerzése a Microsoft planetáris számítógépéről
  2. A token regisztrálása adatforrásként a GeoCatalogban
  3. STAC-elemek közzététele a gyűjteményből a GeoCatalog Item API-ba
  4. Ellenőrizze, hogy az elemek betöltése sikeresen megtörtént-e
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)

A planetáris számítógép lekérdezése

Először le kell kérdeznie a planetáris számítógépet, hogy megkeresse az adott követelményeknek megfelelő Sentinel-2 rendszerképeket. Ebben az esetben a Következő feltételeknek megfelelő Sentinel-2-képeket keres a Planetary Computerben:

  • Gyűjtemény – Képek a Sentinel-2-l2a gyűjteményből
  • Időtartomány – Összegyűjtve 2024. február 4. és február 11. között
  • Érdeklődési terület – Dél-Izlandról gyűjtött képek (határoló dobozként definiálva)

A keresés végrehajtásával láthatja, hogy a megfelelő STAC-elemek a Planetary Computerben találhatók.

# 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]

Betöltési forrás regisztrálása

Ahhoz, hogy ezeket a STAC-elemeket és a hozzájuk kapcsolódó objektumokat (képeket) egy GeoCatalog-gyűjteménybe betölthesse, meg kell állapítania, hogy új betöltési forrást kell-e regisztrálnia. A GeoCatalog a betöltési forrásokat használja annak nyomon követésére, hogy mely tárolóhelyekhez (Azure Blob Storage-tárolókhoz) fér hozzá.

A betöltési forrás regisztrálása úgy történik, hogy a GeoCatalog megadja a tároló helyét, és egy SAS-jogkivonatot, amely olvasási engedélyekkel rendelkezik a tároló eléréséhez. Ha a STAC-elemek vagy azok kapcsolódó eszközei tárolóban találhatók, és a GeoCatalog nem kapott hozzáférést, az adatbetöltés sikertelen lesz.

A folyamat elindításához először egy SAS-jogkivonatot kér a Planetary Számítógéptől, amely olvasási hozzáférést biztosít ahhoz a tárolóhoz, amelyben a Sentinel-2 rendszerképek találhatók.

# 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']}")

Következő kísérlet az Azure Blob Storage-tároló és a társított SAS-jogkivonat betöltési forrásként való regisztrálására a GeoCatalog használatával. Lehetséges, hogy már létezik betöltési forrás ehhez a tárolóhoz. Ha igen, keresse meg a meglévő betöltési forrás azonosítóját.

Figyelmeztetés

Ha egy ismétlődő betöltési forrást talál egy jogkivonattal, amely a következő 15 percben lejár, a rendszer törli és lecseréli. A jelenleg futó betöltési folyamatokhoz használt bemeneti forrás törlése megszakíthatja ezeket a folyamatokat.

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"])

STAC-elemek betöltése a GeoCatalog Items API használatával

Most, hogy regisztrált egy betöltési forrást, vagy igazolta, hogy létezik egy forrás, a GeoCatalog Items API használatával betölti a Planetáris számítógépen talált STAC-elemeket. Ezt úgy érheti el, hogy minden elemet az Items API-ba küld, amely létrehoz egy új betöltési műveletet a GeoCatalogon belül.

# 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']}")

Mivel a Sentinel-2 elembetöltés eltarthat egy kis ideig, ezt a kódot futtatva ellenőrizheti a betöltési műveletek állapotát a GeoCatalog Operations API-jával.

# 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 summary 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)

Frissítenie kell a webböngészőt, és az Elemek fülre kattintva megtekintheti ezeket az újonnan feltöltött elemeket.

Gyűjteménykezelés

Most, hogy betöltötte ezeket a STAC-elemeket és a hozzájuk tartozó objektumokat (képeket) a STAC-gyűjteménybe, meg kell adnia a GeoCatalognak néhány más konfigurációs fájlt, mielőtt megjelenítené ezeket az elemeket a GeoCatalog webes felületén.

Gyűjtemény renderelési konfigurációja

Először töltse le a gyűjtemény renderelési konfigurációs fájlját a Planetary Computerből. Ezt a konfigurációs fájlt a GeoCatalog felolvassa, hogy az Explorerben különböző módokon jelenítsen meg képeket. Ennek az az oka, hogy a STAC-elemek számos különböző objektumot (képet) tartalmazhatnak, amelyek kombinálhatók egy adott terület teljesen új lemezképeinek létrehozásához, amelyek kiemelik a látható vagy nem látható funkciókat. Például a Sentinel-2 STAC elemek több mint 12 különböző képpel rendelkeznek a spektrum különböző részeiről az elektromágneses spektrumon. Ez a renderelési konfiguráció arra utasítja a GeoCatalogot, hogyan kombinálhatja ezeket a képeket, hogy természetes színnel vagy hamis színnel (infravörös színnel) jeleníthesse meg a képeket.

# 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']

Miután elolvasta ezt a renderelési beállítások konfigurációját a Planetary Computerről, engedélyezheti ezeket a megjelenítési beállításokat a gyűjteményhez úgy, hogy közzéteszi ezt a konfigurációt a renderelési beállítások végpontra.

# 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}
    )

Mozaikdefiníciók

A fent tárgyalt renderelési konfigurációhoz hasonlóan a GeoCatalog Explorere lehetővé teszi egy vagy több mozaikdefiníció megadását a gyűjteményhez. Ezek a mozaikdefiníciók lehetővé teszik a GeoCatalog Explorerének útmutatását arról, hogyan szűrheti, hogy mely elemek jelenjenek meg az Explorerben. Egy alapszintű renderelési konfiguráció (a következő cellában látható) például arra utasítja a GeoCatalogot, hogy az adott terület legfrissebb képét jelenítse meg. A fejlettebb renderelési konfigurációk lehetővé teszik, hogy különböző nézeteket jelenítsünk meg, például a 2023 októberében rögzített hely legkevésbé felhős képét.

# 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}
)

A GeoCatalog webes felületének megnyitása

Gratula! Létrehozott egy gyűjteményt, hozzáadott STAC-elemeket és -eszközöket, és frissítette a gyűjteményt, hogy tartalmazza a szükséges konfigurációs fájlokat, hogy azok a GeoCatalog webes felületén, az Explorerben is megtekinthetők legyenek.

Lépjen vissza a GeoCatalog Explorerre a webes felületen a gyűjtemény megtekintéséhez!

Lekérdezésgyűjtés a STAC API-val

Most, hogy megtekintette a gyűjteményt a GeoCatalog Explorerben, megtudhatja, hogyan használhatja a GeoCatalog STAC API-jait a STAC-elemek és -objektumok további elemzéshez való kereséséhez és lekéréséhez.

Ez a folyamat a GeoCatalog STAC API-jában való keresés közzétételével kezdődik. Pontosabban olyan képeket fog keresni a gyűjteményében, amelyek a planetáris számítógépről származó képek kinyeréséhez használt eredeti határolókeretbe tartoznak.

Ez a lekérdezés nem meglepő módon a gyűjteményben korábban elhelyezett összes STAC-elemet visszaadja.

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))

Az előző lekérdezésben egy másik paramétert is megadott: sign:true. Ez arra utasítja a GeoCatalogot, hogy adjon vissza egy aláírt href -t (href + SAS-jogkivonatot), amely lehetővé teszi a megadott eszközök olvasását az Azure Blob Storage-ból.

# 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

Erőforrások tisztítása

Elemek törlése

Ezen a ponton létrehozott egy GeoCatalog-gyűjteményt, hozzáadott elemeket és eszközöket a gyűjteményhez, és lekérte ezeket az elemeket és eszközöket a GeoCatalog STAC API-jával. Az oktatóanyag utolsó szakaszában eltávolítja ezeket az elemeket, és törli a gyűjteményt.

# Delete all items

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

A következő parancs futtatásával ellenőrizheti, hogy az összes elem törölve lett-e. Vegye figyelembe, hogy az elemek és a hozzájuk tartozó eszközök teljes törlése egy-két percet is igénybe vehet.

# 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))

Gyűjtemény törlése

Végső lépésként érdemes lehet teljesen törölni a gyűjteményt a GeoCatalog-példányból.

# 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}")

Következő lépések

STAC-gyűjtemény létrehozása a webes felületen

Kapcsolódó tartalom

Ebben a teljes körű oktatóanyagban áttekintést kap egy új STAC-gyűjtemény létrehozásának folyamatáról, a Sentinel-2 rendszerképek gyűjteménybe való beillesztéséről és a képek GeoCatalog API-kkal történő lekérdezéséről. Ha szeretne többet megtudni ezekről a témakörökről, tekintse meg az alábbi további anyagokat:

  • Last updated on