Samouczek: używanie interfejsów API Microsoft Planetary Computer Pro do pozyskiwania i wizualizowania danych

Kolekcje STAC (SpatioTemporal Asset Catalog) są używane w usłudze GeoCatalog do indeksowania i przechowywania powiązanych zasobów spatiotemporalnych. W tym kompleksowym samouczku utworzysz nową kolekcję STAC, zaimportujesz obrazy Sentinel-2 do kolekcji i wykonasz zapytania dotyczące tych obrazów za pomocą interfejsów API usługi GeoCatalog.

W tym samouczku nauczysz się następujących rzeczy:

Utworzy Twoją własną kolekcję STAC w Planetary Computer Pro GeoCatalog
Pozyskiwanie zdjęć satelitarnych do tej kolekcji z Europejskiej Agencji Kosmicznej
Konfigurowanie kolekcji w taki sposób, aby obrazy w kolekcji mogły być wizualizowane w interfejsie internetowym firmy Planetary Computer Pro
Wykonywanie zapytań o dane z kolekcji STAC przy użyciu interfejsu API STAC firmy Planetary Computer Pro

W tym samouczku pokazano i wyjaśniono możliwości za pomocą fragmentów kodu, aby uzyskać interaktywne doświadczenie w stylu notesu, pobierz ten samouczek jako notebook Jupyter.

Wymagania wstępne

Przed uruchomieniem tego samouczka potrzebny jest serwer GeoCatalog Planetary Computer Pro wdrożony w ramach subskrypcji platformy Azure. Potrzebujesz również środowiska do uruchomienia tego notebooka oraz zainstalowania niezbędnych pakietów. Zalecamy uruchomienie tego samouczka na maszynie wirtualnej Azure Machine Learning lub za pośrednictwem integracji notesu w programie Visual Studio Code w środowisku wirtualnym Pythona. Jednak ten notebook powinien działać wszędzie tam, gdzie można uruchamiać notebooki Jupyter, pod warunkiem spełnienia następujących wymagań:

Środowisko Python w wersji 3.10 lub nowszej
Azure CLI jest zainstalowane, a Ty wykonałeś polecenie az login, aby zalogować się do swojego konta Azure.
Zainstalowane są niezbędne wymagania wymienione w sekcji Opcje samouczka

Otwieranie notesu Jupyter w usłudze Azure Machine Learning lub VS Code

Zaloguj się do platformy Azure za pomocą Azure CLI

Następujące polecenie loguje Cię do platformy Azure przy użyciu Azure CLI. Uruchom polecenie i postępuj zgodnie z instrukcjami, aby się zalogować.

!az login

Wybieranie opcji samouczka

Przed uruchomieniem tego samouczka musisz mieć dostęp współautora do istniejącego wystąpienia usługi GeoCatalog. Wprowadź adres URL wystąpienia GeoCatalog w zmiennej „geocatalog_url”. W tym samouczku utworzysz kolekcję obrazów z usługi Sentinel-2 dostarczonych przez Europejską Agencję Kosmiczną (ESA), które są obecnie przechowywane w katalogu danych komputerów planetarnych firmy 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

Importowanie wymaganych pakietów

Przed utworzeniem kolekcji STAC należy zaimportować kilka pakietów języka Python i zdefiniować funkcje pomocnika w celu pobrania wymaganego tokenu dostępu.

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

Tworzenie kolekcji STAC

Definiowanie kolekcji STAC w formacie JSON

Następnie zdefiniujesz kolekcję STAC jako element JSON. Na potrzeby tego samouczka użyj istniejącego kodu JSON kolekcji STAC dla kolekcji Sentinel-2-l2a w ramach Planetary Computer firmy Microsoft. Kolekcja ma przypisany losowy identyfikator i tytuł, aby nie powodować konfliktu z innymi istniejącymi kolekcjami.

# 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

Podczas tworzenia kolekcji w usłudze GeoCatalog kod JSON kolekcji nie może mieć żadnych zasobów na poziomie kolekcji (takich jak miniatura kolekcji) skojarzonych z kolekcją, więc najpierw usuń te istniejące zasoby (nie martw się, że dodasz miniaturę później).

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

Otwórz interfejs internetowy GeoCatalog i powinna być widoczna nowa kolekcja na karcie "Kolekcje".

Miniatura kolekcji programu Access

Następnie chcesz dodać miniaturę do naszej kolekcji, która ma być wyświetlana wraz z naszą kolekcją. Na potrzeby tego pokazu użyj miniatury z istniejącej kolekcji Sentinel-2 w ramach komputera planetarnego firmy 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

Dodawanie miniatury do komputera planetarnego Pro GeoCatalog

Po przeczytaniu miniatury możesz dodać ją do naszej kolekcji, publikując ją w punkcie końcowym interfejsu API zasobów kolekcji geocatalogs wraz z wymaganym plikiem json zasobu.

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

Odczytywanie nowej kolekcji z poziomu geokatalogu Planetary Computer Pro

Odśwież przeglądarkę i powinna być widoczna miniatura. Możesz również programowo pobrać kod JSON kolekcji, wykonując następujące wywołanie punktu końcowego kolekcji:

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

Pozyskiwanie elementów STAC i zasobów

Po utworzeniu tej kolekcji możesz przystąpić do pobierania nowych elementów STAC do swojej kolekcji STAC, używając interfejsu API elementów GeoCatalog. Ten proces można wykonać, wykonując następujące czynności:

Uzyskiwanie tokenu SAS z komputera planetarnego firmy Microsoft
Rejestrowanie tego tokenu jako źródła pozyskiwania w usłudze GeoCatalog
Opublikuj elementy STAC z tego zbioru do interfejsu API elementów GeoCatalogu
Sprawdź, czy elementy zostały pomyślnie wczytane

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)

Zapytaj komputer planetarny

Najpierw należy wysłać zapytanie do komputera planetarnego, aby wyszukać obrazy Sentinel-2 spełniające nasze konkretne wymagania. W tym przypadku szukasz obrazów Sentinel-2 w komputerze planetarnym, który spełnia następujące kryteria:

Kolekcja — obrazy z kolekcji Sentinel-2-l2a
Zakres czasu — zebrane od 4 lutego do 11 lutego 2024 r.
Obszar zainteresowania - Zdjęcia zebrane na południowej Islandii (zdefiniowane jako obszar ograniczony prostokątem)

Wykonując to wyszukiwanie, można zobaczyć, że pasujące elementy STAC znajdują się w komputerze planetarnym.

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

Zarejestruj źródło wprowadzania

Przed pozyskaniem tych elementów STAC i powiązanych zasobów (obrazów) do kolekcji GeoCatalog należy określić, czy musisz zarejestrować nowe źródło pozyskiwania. Źródła pobierania są używane przez GeoCatalog do śledzenia lokalizacji magazynu (kontenerów usługi Azure Blob Storage), do których ma dostęp.

Zarejestrowanie źródła pozyskiwania wymaga podania GeoCatalog lokalizacji kontenera magazynowego oraz tokenu SAS z uprawnieniami do odczytu, aby uzyskać dostęp do kontenera. Jeśli elementy STAC lub powiązane zasoby znajdują się w kontenerze magazynowym, do którego GeoCatalog nie ma przyznanego dostępu, proces pozyskiwania zakończy się niepowodzeniem.

Aby rozpocząć ten proces, najpierw zażądasz tokenu SAS z komputera planetarnego, który udziela nam dostępu do odczytu do kontenera, w którym znajdują się obrazy Sentinel-2.

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

Następnie spróbuj zarejestrować ten kontener usługi Azure Blob Storage i skojarzony token SAS jako źródło danych w usłudze GeoCatalog. Możliwe, że źródło pozyskiwania już istnieje dla tego kontenera magazynowego. Jeśli tak, znajdź identyfikator istniejącego źródła pozyskiwania.

Ostrzeżenie

Jeśli zostanie znalezione zduplikowane źródło pozyskiwania z tokenem, który wygaśnie w ciągu najbliższych 15 minut, to zostanie ono usunięte i zastąpione. Usunięcie źródła pobierania, które jest używane przez aktualnie uruchomione procesy pobierania, może przerwać te procesy.

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

Pozyskiwanie elementów STAC przy użyciu GeoCatalog's Items API

Po zarejestrowaniu źródła pozyskiwania lub sprawdzeniu, czy źródło istnieje, pozyskasz elementy STAC znalezione w komputerze planetarnym przy użyciu interfejsu API elementów geokatalogu. Aby to osiągnąć, opublikuj każdy element w Items API, które tworzy nową operację importu danych w usłudze 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']}")

Biorąc pod uwagę, że pozyskiwanie elementów Sentinel-2 może zająć trochę czasu, możesz uruchomić ten kod, aby sprawdzić stan operacji pozyskiwania przy użyciu interfejsu API Operacji GeoCatalogu.

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

Powinno być możliwe odświeżenie przeglądarki internetowej i kliknięcie karty Elementy, aby wyświetlić te nowo przekazane elementy.

Zarządzanie kolekcjami

Po wprowadzeniu tych elementów STAC i powiązanych z nimi zasobów (obrazów) do kolekcji STAC, musisz dostarczyć do swojego GeoCatalogu inne pliki konfiguracyjne, zanim będzie można wyświetlić te elementy w interfejsie webowym GeoCatalog.

Konfiguracja renderowania kolekcji

Najpierw pobierz plik konfiguracji renderowania dla tej kolekcji z komputera planetarnego. Ten plik konfiguracji można odczytać za pomocą geokatalogu w celu renderowania obrazów na różne sposoby w Eksploratorze. Jest to spowodowane tym, że elementy STAC mogą zawierać wiele różnych zasobów (obrazów), które można połączyć w celu utworzenia całkowicie nowych obrazów danego obszaru, który wyróżnia widoczne lub niewidoczne cechy. Na przykład elementy STAC sentinel-2 mają ponad 12 różnych obrazów z różnych części spektrum elektromagnetycznego. Ta konfiguracja renderowania instruuje GeoCatalog, jak łączyć te obrazy, aby mógł wyświetlać obrazy w Kolorze Naturalnym lub Kolorze Fałszywym (Kolor w Podczerwieni).

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

Po przeczytaniu tej konfiguracji opcji renderowania z komputera planetarnego można włączyć te opcje renderowania dla kolekcji, publikując tę konfigurację w punkcie końcowym opcji renderowania.

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

Definicje mozaiki

Podobnie jak w powyższej konfiguracji renderowania eksplorator GeoCatalog umożliwia określenie co najmniej jednej definicji mozaiki dla kolekcji. Te definicje mozaiki umożliwiają nam poinstruowanie Eksploratora GeoCatalog na temat filtrowania elementów wyświetlanych w Eksploratorze. Na przykład jedna podstawowa konfiguracja renderowania (pokazana w następnej komórce) nakazuje usłudze GeoCatalog wyświetlenie najnowszego obrazu dla dowolnego obszaru. Bardziej zaawansowane konfiguracje renderowania umożliwiają renderowanie różnych widoków, takich jak najmniej chmurowy obraz dla danej lokalizacji przechwyconej w październiku 2023 r.

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

Otwórz interfejs sieciowy GeoCatalog

Gratulacje! Utworzono kolekcję, dodano elementy STAC i zasoby oraz zaktualizowano kolekcję w celu uwzględnienia wymaganych plików konfiguracji, aby można było je wyświetlić za pośrednictwem Eksploratora w interfejsie internetowym GeoCatalog.

Wróć do Eksploratora geokatalogu w interfejsie internetowym, aby wyświetlić kolekcję!

Zbieranie zapytań za pośrednictwem interfejsu API STAC

Teraz, po wyświetleniu kolekcji w Eksploratorze GeoCatalog, dowiesz się, jak używać interfejsów API STAC GeoCatalog do wyszukiwania i pobierania elementów i zasobów STAC w celu dalszej analizy.

Ten proces rozpoczyna się od opublikowania wyszukiwania w interfejsie API STAC usługi GeoCatalog. W szczególności wyszukasz zdjęcia w kolekcji, które znajdują się w oryginalnym polu ograniczenia użytym do wyodrębnienia zdjęć z Planetary Computer.

Nic dziwnego, że to zapytanie zwraca wszystkie elementy STAC wcześniej umieszczone w kolekcji.

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

W poprzednim zapytaniu podano również inny parametr: sign:true. Spowoduje to, że GeoCatalog zwróci podpisany href (element href + token SAS), który umożliwia odczytywanie zasobów z 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

Uprzątnij zasoby

Usuń elementy

Na tym etapie utworzono kolekcję GeoCatalog, dodano elementy i zasoby do kolekcji oraz pobrano te elementy i zasoby przy użyciu interfejsu API STAC usługi GeoCatalog. W ostatniej fazie tego samouczka usuniesz te elementy i usuniesz kolekcję.

# Delete all items

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

Możesz potwierdzić, że wszystkie elementy zostały usunięte, uruchamiając następne polecenie. Pamiętaj, że całkowite usunięcie elementów i skojarzonych z nimi zasobów może potrwać minutę lub dwie.

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

Usuwanie kolekcji

Teraz, na zakończenie, możesz w pełni usunąć kolekcję z instancji GeoCatalog.

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

Dalsze kroki

Tworzenie kolekcji STAC za pomocą interfejsu internetowego

W tym kompleksowej części samouczka przedstawiono proces tworzenia nowej kolekcji STAC, pozyskiwania obrazów usługi Sentinel-2 do kolekcji i wykonywania zapytań dotyczących tych obrazów za pośrednictwem interfejsów API usługi GeoCatalog. Jeśli chcesz dowiedzieć się więcej na temat każdego z tych tematów, zapoznaj się z innymi materiałami:

Opinia

Czy ta strona była pomocna?

Last updated on 2025-05-20