eotdl 2024.10.7__py3-none-any.whl → 2025.3.25__py3-none-any.whl

eotdl/curation/stac/extensions/eo.py

@@ -1,117 +0,0 @@
-"""
-Module for EO STAC extensions object
-"""
-
-from typing import Union
-
-import pystac
-import pandas as pd
-
-from pystac.extensions.eo import Band, EOExtension
-
-from .base import STACExtensionObject
-
-
-class EOS2ExtensionObject(STACExtensionObject):
-    """
-    EO STAC extension object
-    """
-    def __init__(self) -> None:
-        super().__init__()
-        self.bands_dict = {
-            "B01": Band.create(
-                name="B01",
-                description="Coastal aerosol, 442.7 nm (S2A), 442.3 nm (S2B)",
-                common_name="coastal",
-            ),
-            "B02": Band.create(
-                name="B02",
-                description="Blue, 492.4 nm (S2A), 492.1 nm (S2B)",
-                common_name="blue",
-            ),
-            "B03": Band.create(
-                name="B03",
-                description="Green, 559.8 nm (S2A), 559.0 nm (S2B)",
-                common_name="green",
-            ),
-            "B04": Band.create(
-                name="B04",
-                description="Red, 664.6 nm (S2A), 665.0 nm (S2B)",
-                common_name="red",
-            ),
-            "B05": Band.create(
-                name="B05",
-                description="Vegetation red edge, 704.1 nm (S2A), 703.8 nm (S2B)",
-                common_name="rededge",
-            ),
-            "B06": Band.create(
-                name="B06",
-                description="Vegetation red edge, 740.5 nm (S2A), 739.1 nm (S2B)",
-                common_name="rededge",
-            ),
-            "B07": Band.create(
-                name="B07",
-                description="Vegetation red edge, 782.8 nm (S2A), 779.7 nm (S2B)",
-                common_name="rededge",
-            ),
-            "B08": Band.create(
-                name="B08",
-                description="NIR, 832.8 nm (S2A), 833.0 nm (S2B)",
-                common_name="nir",
-            ),
-            "B08a": Band.create(
-                name="B08a",
-                description="Narrow NIR, 864.7 nm (S2A), 864.0 nm (S2B)",
-                common_name="nir08",
-            ),
-            "B09": Band.create(
-                name="B09",
-                description="Water vapour, 945.1 nm (S2A), 943.2 nm (S2B)",
-                common_name="nir09",
-            ),
-            "B10": Band.create(
-                name="B10",
-                description="SWIR – Cirrus, 1373.5 nm (S2A), 1376.9 nm (S2B)",
-                common_name="cirrus",
-            ),
-            "B11": Band.create(
-                name="B11",
-                description="SWIR, 1613.7 nm (S2A), 1610.4 nm (S2B)",
-                common_name="swir16",
-            ),
-            "B12": Band.create(
-                name="B12",
-                description="SWIR, 2202.4 nm (S2A), 2185.7 nm (S2B)",
-                common_name="swir22",
-            ),
-        }
-
-    def add_extension_to_object(
-        self, obj: Union[pystac.Item, pystac.Asset], obj_info: pd.DataFrame
-    ) -> Union[pystac.Item, pystac.Asset]:
-        """
-        Add the extension to the given object
-
-        :param obj: object to add the extension
-        :param obj_info: object info from the STACDataFrame
-        """
-        # Add EO extension
-        eo_ext = EOExtension.ext(obj, add_if_missing=True)
-        # Add common metadata
-        if isinstance(obj, pystac.Item) or (
-            isinstance(obj, pystac.Asset) and obj.title not in self.bands_dict.keys()
-        ):
-            obj.common_metadata.constellation = "Sentinel-2"
-            obj.common_metadata.platform = "Sentinel-2"
-            obj.common_metadata.instruments = ["Sentinel-2"]
-            obj.common_metadata.gsd = 10
-            # Add bands
-            bands = obj_info["bands"].values
-            bands = bands[0] if bands else None
-            bands_list = [self.bands_dict[band] for band in bands] if bands else None
-            eo_ext.apply(bands=bands_list)
-
-        elif isinstance(obj, pystac.Asset):
-            eo_ext.apply(bands=[self.bands_dict[obj.title]])
-
-        return obj

eotdl/curation/stac/extensions/label/__init__.py

@@ -1,7 +0,0 @@
-"""
-STAC label extension module
-"""
-
-from .base import LabelExtensionObject
-from .image_name_labeler import ImageNameLabeler
-from .scaneo import ScaneoLabeler

eotdl/curation/stac/extensions/label/base.py

@@ -1,136 +0,0 @@
-"""
-Module for the STAC label extension base object
-"""
-
-from typing import List, Union
-
-import pystac
-from pystac.extensions.label import (
-    LabelClasses,
-    LabelExtension,
-    SummariesLabelExtension,
-)
-
-from ..base import STACExtensionObject
-
-
-class LabelExtensionObject(STACExtensionObject):
-    """
-    STAC Label extension base object in EOTDL
-    """
-    def __init__(self) -> None:
-        super().__init__()
-
-    @classmethod
-    def generate_stac_labels(cls) -> None:
-        """
-        Generate a labels collection from a STAC dataframe.
-        """
-        return
-
-    def add_extension_to_item(
-        self,
-        obj: pystac.Item,
-        label_description: str,
-        label_type: str,
-        label_names: List[str],
-        label_classes: List[str],
-        **kwargs
-    ) -> Union[pystac.Item, pystac.Asset]:
-        """
-        Add the extension to the given object
-
-        :param obj: object to add the extension
-        :param label_description: label description
-        :param label_type: label type
-        :param label_names: list of label names
-        :param label_classes: list of label classes of the item
-        :param kwargs: optional arguments
-            :param kwargs.label_properties: list of label properties
-            :param kwargs.label_methods: list of label methods
-            :param kwargs.label_tasks: list of label tasks
-
-        :return: the item with the label extension
-        """
-        label_item = pystac.Item(
-            id=obj.id,
-            geometry=obj.geometry,
-            bbox=obj.bbox,
-            properties={},
-            datetime=obj.datetime,
-        )
-
-        # Add the label extension to the item
-        LabelExtension.add_to(label_item)
-
-        # Access the label extension
-        label_ext = LabelExtension.ext(label_item)
-
-        # Add the label classes
-        for name, classes in zip(label_names, label_classes):
-            label_classes = LabelClasses.create(
-                name=name,
-                classes=classes,
-            )
-            label_ext.label_classes = [label_classes]
-
-        # Add the label description
-        label_ext.label_description = label_description
-        # Add the label type
-        label_ext.label_type = label_type
-        # Add the label properties, if any
-        label_ext.label_properties = (
-            kwargs.get("label_properties")
-            if kwargs.get("label_properties", None)
-            else label_names
-        )
-        # Add the label methods, if any
-        label_ext.label_methods = (
-            kwargs.get("label_methods") if kwargs.get("label_methods", None) else None
-        )
-        # Add the label tasks, if any
-        label_ext.label_tasks = (
-            kwargs.get("label_tasks") if kwargs.get("label_tasks", None) else None
-        )
-        # Add the source
-        label_ext.add_source(obj)
-
-        return label_item
-
-    def add_extension_to_collection(
-        self,
-        obj: pystac.Collection,
-        label_names: List[str],
-        label_classes: List[Union[list, tuple]],
-        label_type: str,
-    ) -> None:
-        """
-        Add the label extension to the given collection
-
-        :param obj: object to add the extension
-        :param label_names: list of label names
-        :param label_classes: list of label classes
-        :param label_type: label type
-        """
-        LabelExtension.add_to(obj)
-
-        # Add the label extension to the collection
-        label_ext = SummariesLabelExtension(obj)
-
-        # Add the label classes
-        for name, classes in zip(label_names, label_classes):
-            label_classes = LabelClasses.create(
-                name=name,
-                classes=classes,
-            )
-            label_ext.label_classes = [label_classes]
-
-        # Add the label type
-        label_ext.label_type = label_type
-
-    def add_geojson_to_items(self) -> None:
-        """
-        Add a GeoJSON FeatureCollection to every label item, as recommended by the spec
-        https://github.com/stac-extensions/label#assets
-        """
-        return

eotdl/curation/stac/extensions/label/image_name_labeler.py

@@ -1,203 +0,0 @@
-"""
-Module for the STAC label extension ImageNameLabeler object
-"""
-
-import json
-from os.path import join, dirname
-from typing import List, Optional, Union
-
-import pystac
-import pandas as pd
-
-from tqdm import tqdm
-from pystac.extensions.label import LabelExtension
-from ...extent import get_unknow_extent
-from .base import LabelExtensionObject
-
-
-class ImageNameLabeler(LabelExtensionObject):
-    """
-    STAC label extension ImageNameLabeler object in EOTDL
-    """
-    def __init__(self) -> None:
-        super().__init__()
-
-    def generate_stac_labels(
-        self,
-        catalog: Union[pystac.Catalog, str],
-        stac_dataframe: Optional[pd.DataFrame] = None,
-        collection: Optional[Union[pystac.Collection, str]] = "source",
-        label_description: Optional[str] = "Item label",
-        label_type: Optional[str] = "vector",
-        label_names: Optional[List[str]] = ["label"],
-        **kwargs,
-    ) -> None:
-        """
-        Generate a labels collection from a STAC dataframe.
-        This class uses the label column of the dataframe as the label names.
-
-        :param catalog: catalog to add the labels collection to
-        :param stac_dataframe: dataframe with the STAC metadata of a given directory containing the assets to generate metadata
-        :param collection: collection to add the labels collection to
-        :param label_description: label description
-        :param label_type: label type
-        :param label_names: list of label names
-        :param kwargs: optional arguments
-            :param kwargs.label_properties: list of label properties
-            :param kwargs.label_methods: list of label methods
-            :param kwargs.label_tasks: list of label tasks
-        """
-        if stac_dataframe.empty:
-            raise ValueError(
-                "No STAC dataframe provided, please provide a STAC dataframe or generate it with <get_stac_dataframe> method"
-            )
-        if isinstance(catalog, str):
-            catalog = pystac.Catalog.from_file(catalog)
-
-        # Add the labels collection to the catalog
-        # If exists a source collection, get it extent
-        source_collection = catalog.get_child(collection)
-        if source_collection:
-            extent = source_collection.extent
-            source_items = source_collection.get_stac_objects(pystac.RelType.ITEM)
-        else:
-            if not collection:
-                raise ValueError(
-                    "No source collection provided, please provide a source collection"
-                )
-            extent = get_unknow_extent()
-
-        # Create the labels collection and add it to the catalog if it does not exist
-        # If it exists, remove it
-        collection = pystac.Collection(id="labels", description="Labels", extent=extent)
-        if collection.id in [c.id for c in catalog.get_children()]:
-            catalog.remove_child(collection.id)
-        catalog.add_child(collection)
-
-        # Generate the labels items
-        print("Generating labels collection...")
-        for source_item in tqdm(source_items):
-            # There must be an item ID column in the STAC dataframe
-            if "id" not in stac_dataframe.columns:
-                raise ValueError(
-                    "No item ID column found in the STAC dataframe, please provide a STAC dataframe with the item ID column"
-                )
-            label_classes = stac_dataframe.label.unique().tolist()
-
-            # Create the label item
-            label_item = self.add_extension_to_item(
-                source_item,
-                label_description=label_description,
-                label_type=label_type,
-                label_names=[label_names],
-                label_classes=[label_classes],
-                **kwargs,
-            )
-            # Add the self href to the label item, following the Best Practices Layout
-            # https://github.com/radiantearth/stac-spec/blob/master/best-practices.md
-            label_item.set_self_href(
-                join(
-                    dirname(collection.get_self_href()),
-                    label_item.id,
-                    f"{label_item.id}.json",
-                )
-            )
-            collection.add_item(label_item)
-
-        # Add the extension to the collection
-        self.add_extension_to_collection(
-            collection,
-            label_names=[label_names],
-            label_classes=[label_classes],
-            label_type=label_type,
-        )
-
-        # Validate and save the catalog
-        # Before adding the geojson, we need to save the catalog
-        # and then iterate over the items to add the geojson
-        try:
-            pystac.validation.validate(catalog)
-            catalog.normalize_and_save(
-                dirname(catalog.get_self_href()), pystac.CatalogType.SELF_CONTAINED
-            )
-        except pystac.STACValidationError as e:
-            raise pystac.STACError(f"Catalog validation error: {e}")
-
-        # Add a GeoJSON FeatureCollection to every label item, as recommended by the spec
-        # https://github.com/stac-extensions/label#assets
-        self.add_geojson_to_items(collection, stac_dataframe, label_type=label_type)
-        catalog.normalize_and_save(
-            dirname(catalog.get_self_href()), pystac.CatalogType.SELF_CONTAINED
-        )
-        print("Success on labels generation!")
-
-    def add_geojson_to_items(
-        self, collection: pystac.Collection, df: pd.DataFrame, label_type: str
-    ) -> None:
-        """
-        Add a GeoJSON FeatureCollection to every label item, as recommended by the spec
-        https://github.com/stac-extensions/label#assets
-
-        :param collection: collection to add the labels collection to
-        :param df: dataframe with the STAC metadata of a given directory containing the assets to generate metadata
-        :param label_type: label type
-        """
-        for item in collection.get_all_items():
-            geojson_path = join(dirname(item.get_self_href()), f"{item.id}.geojson")
-
-            properties = {"roles": ["labels", f"labels-{label_type}"]}
-
-            # TODO depending on the tasks, there must be extra fields
-            # https://github.com/stac-extensions/label#assets
-            if "label:tasks" in item.properties:
-                tasks = item.properties["label:tasks"]
-                if "tile_regression" in tasks:
-                    pass
-                elif any(
-                    task in tasks
-                    for task in (
-                        "tile_classification",
-                        "object_detection",
-                        "segmentation",
-                    )
-                ):
-                    pass
-
-            label_ext = LabelExtension.ext(item)
-            label_ext.add_geojson_labels(
-                href=geojson_path, title="Label", properties=properties
-            )
-            item.make_asset_hrefs_relative()
-
-            item_id = item.id
-            geometry = item.geometry
-            labels = [df[df["id"] == item_id]["label"].values[0]]
-            # There is data like DEM data that does not have datetime but start and end datetime
-            datetime = (
-                item.datetime.isoformat()
-                if item.datetime
-                else (
-                    item.properties.start_datetime.isoformat(),
-                    item.properties.end_datetime.isoformat(),
-                )
-            )
-            labels_properties = (
-                dict(zip(item.properties["label:properties"], labels))
-                if label_type == "vector"
-                else {}
-            )
-            labels_properties["datetime"] = datetime
-
-            geojson = {
-                "type": "FeatureCollection",
-                "features": [
-                    {
-                        "type": "Feature",
-                        "geometry": geometry,
-                        "properties": labels_properties,
-                    }
-                ],
-            }
-
-            with open(geojson_path, "w", encoding="utf-8") as f:
-                json.dump(geojson, f)

eotdl/curation/stac/extensions/label/scaneo.py

@@ -1,219 +0,0 @@
-"""
-Module for the STAC label extension ScaneoLabeler object
-"""
-
-import json
-from os.path import join, dirname, exists, splitext, basename, abspath
-from typing import List, Optional, Union
-from glob import glob
-
-import pystac
-
-from tqdm import tqdm
-from pystac.extensions.label import LabelExtension
-
-from .base import LabelExtensionObject
-from ...extent import get_unknow_extent
-
-
-class ScaneoLabeler(LabelExtensionObject):
-    """
-    STAC label extension ScaneoLabeler object in EOTDL
-    """
-    def __init__(self) -> None:
-        super().__init__()
-
-    def generate_stac_labels(
-        self,
-        catalog: Union[pystac.Catalog, str],
-        root_folder: str,
-        collection: Optional[Union[pystac.Collection, str]] = "source",
-        label_description: Optional[str] = "Item label",
-        label_type: Optional[str] = "vector",
-        label_names: Optional[List[str]] = ["label"],
-        **kwargs,
-    ) -> None:
-        """
-        Generate a labels collection from a STAC dataframe.
-        This class should be used when the items have been labeled using SCANEO, as is implemented
-        taking into account the SCANEO labeling format.
-
-        :param catalog: catalog to add the labels collection to
-        :param root_folder: root folder where are the images and the labels as GeoJSON files, following the SCANEO labeling format
-        :param stac_dataframe: dataframe with the STAC metadata of a given directory containing the assets to generate metadata
-        :param collection: collection to add the labels collection to
-        :param label_description: label description
-        :param label_type: label type
-        :param label_names: list of label names
-        :param kwargs: optional arguments
-            :param kwargs.label_properties: list of label properties
-            :param kwargs.label_methods: list of label methods
-        """
-        if isinstance(catalog, str):
-            catalog = pystac.Catalog.from_file(catalog)
-
-        # Add the labels collection to the catalog
-        # If exists a source collection, get it extent
-        source_collection = catalog.get_child(collection)
-        if source_collection:
-            extent = source_collection.extent
-            source_items = source_collection.get_stac_objects(pystac.RelType.ITEM)
-        else:
-            if not collection:
-                raise ValueError(
-                    "No source collection provided, please provide a source collection"
-                )
-            extent = get_unknow_extent()
-
-        # Create the labels collection and add it to the catalog if it does not exist
-        # If it exists, remove it
-        collection = pystac.Collection(id="labels", description="Labels", extent=extent)
-        if collection.id in [c.id for c in catalog.get_children()]:
-            catalog.remove_child(collection.id)
-        catalog.add_child(collection)
-
-        # Get the GeoJSON files
-        geojson_files = glob(join(root_folder, "*.geojson"))
-        if not geojson_files:
-            raise ValueError(
-                "No GeoJSON files found in the root folder, please provide a root folder with the GeoJSON files"
-            )
-
-        # Get the label classes
-        label_classes = self.get_label_classes(root_folder, geojson_files)
-
-        # Generate the labels items
-        for source_item in tqdm(source_items, desc="Generating labels collection..."):
-            # Get the GeoJSON label of the item
-            geojson_label = self.get_geojson_of_item(source_item, geojson_files)
-            # Get the tasks from the GeoJSON label
-            tasks = self.get_tasks_from_geojson(geojson_label) if geojson_label else None
-            # Add the tasks to the kwargs
-            kwargs["label_tasks"] = tasks
-
-            # Create the label item
-            label_item = self.add_extension_to_item(
-                source_item,
-                label_description=label_description,
-                label_type=label_type,
-                label_names=label_names,
-                label_classes=label_classes,
-                **kwargs,
-            )
-            # Add the self href to the label item, following the Best Practices Layout
-            # https://github.com/radiantearth/stac-spec/blob/master/best-practices.md
-            label_item.set_self_href(
-                join(
-                    dirname(collection.get_self_href()),
-                    label_item.id,
-                    f"{label_item.id}.json",
-                )
-            )
-            # Match the GeoJSON label with the label item, if exists
-            if geojson_label and exists(geojson_label):
-                self.add_geojson_to_item(label_item, geojson_label, label_type)
-            # Add the item to the collection
-            collection.add_item(label_item)
-
-        # Add the extension to the collection
-        self.add_extension_to_collection(
-            collection,
-            label_names=[label_names],
-            label_classes=[label_classes],
-            label_type=label_type,
-        )
-
-        # Validate and save the catalog
-        # Before adding the geojson, we need to save the catalog
-        # and then iterate over the items to add the geojson
-        try:
-            pystac.validation.validate(catalog)
-            catalog.normalize_and_save(
-                dirname(catalog.get_self_href()), pystac.CatalogType.SELF_CONTAINED
-            )
-            print("Success on labels generation!")
-        except pystac.STACValidationError as e:
-            raise pystac.STACError(f"Catalog validation error: {e}")
-
-    def add_geojson_to_item(
-        self, item: pystac.Item, geojson_path: str, label_type: str
-    ) -> None:
-        """
-        Add a GeoJSON FeatureCollection to every label item, as recommended by the spec
-        https://github.com/stac-extensions/label#assets
-
-        :param collection: collection to add the labels collection to
-        :param df: dataframe with the STAC metadata of a given directory containing the assets to generate metadata
-        :param label_type: label type
-        """
-        properties = {"roles": ["labels", f"labels-{label_type}"]}
-
-        label_ext = LabelExtension.ext(item, add_if_missing=True)
-        item.make_asset_hrefs_absolute()
-        label_ext.add_geojson_labels(
-            href=abspath(geojson_path), title="Label", properties=properties
-        )
-        item.make_asset_hrefs_relative()
-
-    def get_label_classes(self, root_folder: str, geojsons: List[str]) -> List[str]:
-        """
-        Get the label classes from the labels.json file if exists, or from the GeoJSON files instead
-        """
-        label_classes = []
-
-        labels_json = glob(join(root_folder, "labels.json"))
-        if len(labels_json) > 0 and exists(labels_json[0]):
-            labels_json = labels_json[0]
-            with open(labels_json, "r", encoding="utf-8") as f:
-                labels = json.load(f)
-            for value in labels["labels"]:
-                label_classes.append(value["name"]) if value[
-                    "name"
-                ] not in label_classes else None
-        else:
-            for geojson in geojsons:
-                with open(geojson, "r", encoding="utf-8") as f:
-                    labels = json.load(f)
-                for value in labels["features"]:
-                    label_classes.append(value["properties"]["labels"]) if value[
-                        "properties"
-                    ]["labels"] not in label_classes else None
-
-        return [label_classes]
-
-    def get_geojson_of_item(self, item: pystac.Item, geojsons: List[str]) -> str:
-        """
-        Get the GeoJSON label of the item from a list of GeoJSON files
-
-        :param item: item to get the GeoJSON label
-        :param geojsons: list of GeoJSON files
-
-        :return: path to the GeoJSON label of the item
-        """
-        item_id = item.id
-        geojson_name = f"{item_id}_labels"
-        # Get a dict with <geojson_filename>: <geojson_path>, as the geojson_filename
-        # must match the item ID
-        geojsons_dict = dict(
-            zip([splitext(basename(geojson))[0] for geojson in geojsons], geojsons)
-        )
-        geojson_path = geojsons_dict.get(geojson_name)
-
-        return geojson_path
-
-    def get_tasks_from_geojson(self, geojson_path: str) -> List[str]:
-        """
-        Get the tasks from the GeoJSON label
-
-        :param geojson_path: path to the GeoJSON label
-
-        :return: list of tasks
-        """
-        with open(geojson_path, "r", encoding="utf-8") as f:
-            geojson = json.load(f)
-            tasks = []
-            for feature in geojson["features"]:
-                for task in feature["properties"]["tasks"]:
-                    tasks.append(task) if task not in tasks else None
-
-        return tasks