geoai-py 0.4.2__py2.py3-none-any.whl → 0.4.3__py2.py3-none-any.whl

geoai/__init__.py

@@ -2,7 +2,7 @@
 
 __author__ = """Qiusheng Wu"""
 __email__ = "giswqs@gmail.com"
-__version__ = "0.4.2"
+__version__ = "0.4.3"
 
 
 import os

geoai/download.py

@@ -10,8 +10,9 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 import planetary_computer as pc
+import pystac
 import requests
-import rioxarray
+import rioxarray as rxr
 import xarray as xr
 from pystac_client import Client
 from shapely.geometry import box
@@ -121,7 +122,7 @@ def download_naip(
                 #
             else:
                 # Fallback to direct rioxarray opening (less common case)
-                data = rioxarray.open_rasterio(rgb_asset.href)
+                data = rxr.open_rasterio(rgb_asset.href)
                 data.rio.to_raster(output_path)
 
             downloaded_files.append(output_path)
@@ -129,7 +130,7 @@ def download_naip(
 
             # Optional: Display a preview (uncomment if needed)
             if preview:
-                data = rioxarray.open_rasterio(output_path)
+                data = rxr.open_rasterio(output_path)
                 preview_raster(data)
 
         except Exception as e:
@@ -516,7 +517,7 @@ def download_pc_stac_item(
                     )
                 # Still need to open the file to get the data for merging
                 if merge_bands:
-                    band_data = rioxarray.open_rasterio(file_path)
+                    band_data = rxr.open_rasterio(file_path)
                     band_data_arrays.append((band, band_data))
                     band_names.append(band)
                 result[band] = file_path
@@ -525,7 +526,7 @@ def download_pc_stac_item(
         if show_progress and not isinstance(progress_iter, list):
             progress_iter.set_description(f"Downloading {band}")
 
-        band_data = rioxarray.open_rasterio(band_url)
+        band_data = rxr.open_rasterio(band_url)
 
         # Store the data array for potential merging later
         if merge_bands:
@@ -866,10 +867,9 @@ def pc_stac_search(
 def pc_stac_download(
     items,
     output_dir=".",
-    asset_keys=None,
+    assets=None,
     max_workers=4,
     skip_existing=True,
-    sign_urls=True,
 ):
     """
     Download assets from STAC items retrieved from the Planetary Computer.
@@ -882,7 +882,7 @@ def pc_stac_download(
         items (list or pystac.Item): STAC Item object or list of STAC Item objects.
         output_dir (str, optional): Directory where assets will be saved.
             Defaults to current directory.
-        asset_keys (list, optional): List of asset keys to download. If None,
+        assets (list, optional): List of asset keys to download. If None,
             downloads all available assets. Defaults to None.
         max_workers (int, optional): Maximum number of concurrent download threads.
             Defaults to 4.
@@ -899,7 +899,7 @@ def pc_stac_download(
         TypeError: If items is not a STAC Item or list of STAC Items.
         IOError: If there's an error writing the downloaded assets to disk.
     """
-    import pystac
+
     from concurrent.futures import ThreadPoolExecutor, as_completed
 
     # Handle single item case
@@ -911,31 +911,13 @@ def pc_stac_download(
     # Create output directory if it doesn't exist
     os.makedirs(output_dir, exist_ok=True)
 
-    # Function to sign URLs if needed
-    def get_signed_url(href):
-        if not sign_urls:
-            return href
-
-        # Planetary Computer typically requires signing URLs for accessing data
-        # Check if the URL is from Microsoft Planetary Computer
-        if "planetarycomputer" in href:
-            try:
-                sign_url = "https://planetarycomputer.microsoft.com/api/sas/v1/sign"
-                response = requests.get(sign_url, params={"href": href})
-                response.raise_for_status()
-                return response.json().get("href", href)
-            except Exception as e:
-                print(f"Warning: Failed to sign URL {href}: {str(e)}")
-                return href
-        return href
-
     # Function to download a single asset
     def download_asset(item, asset_key, asset):
+        item = pc.sign(item)
         item_id = item.id
 
         # Get the asset URL and sign it if needed
-        asset_url = get_signed_url(asset.href)
-
+        asset_url = item.assets[asset_key].href
         # Determine output filename
         if asset.media_type:
             # Use appropriate file extension based on media type
@@ -995,13 +977,11 @@ def pc_stac_download(
         print(f"Processing STAC item: {item_id}")
 
         # Determine which assets to download
-        if asset_keys:
-            assets_to_download = {
-                k: v for k, v in item.assets.items() if k in asset_keys
-            }
+        if assets:
+            assets_to_download = {k: v for k, v in item.assets.items() if k in assets}
             if not assets_to_download:
                 print(
-                    f"Warning: None of the specified asset keys {asset_keys} found in item {item_id}"
+                    f"Warning: None of the specified asset keys {assets} found in item {item_id}"
                 )
                 print(f"Available asset keys: {list(item.assets.keys())}")
                 continue
@@ -1038,3 +1018,127 @@ def pc_stac_download(
     print(f"\nDownloaded {total_assets} assets for {len(results)} items")
 
     return results
+
+
+def pc_item_asset_list(item):
+    """
+    Retrieve the list of asset keys from a STAC item in the Planetary Computer catalog.
+
+    Args:
+        item (str): The URL of the STAC item.
+
+    Returns:
+        list: A list of asset keys available in the signed STAC item.
+    """
+    if isinstance(item, str):
+        item = pystac.Item.from_file(item)
+
+    if not isinstance(item, pystac.Item):
+        raise ValueError("item_url must be a string (URL) or a pystac.Item object")
+
+    return list(item.assets.keys())
+
+
+def read_pc_item_asset(item, asset, output=None, as_cog=True, **kwargs):
+    """
+    Read a specific asset from a STAC item in the Planetary Computer catalog.
+
+    Args:
+        item (str): The URL of the STAC item.
+        asset (str): The key of the asset to read.
+        output (str, optional): If specified, the path to save the asset as a raster file.
+        as_cog (bool, optional): If True, save the asset as a Cloud Optimized GeoTIFF (COG).
+
+    Returns:
+        xarray.DataArray: The data array for the specified asset.
+    """
+    if isinstance(item, str):
+        item = pystac.Item.from_file(item)
+
+    if not isinstance(item, pystac.Item):
+        raise ValueError("item must be a string (URL) or a pystac.Item object")
+
+    signed_item = pc.sign(item)
+
+    if asset not in signed_item.assets:
+        raise ValueError(
+            f"Asset '{asset}' not found in item '{item.id}'. It has available assets: {list(signed_item.assets.keys())}"
+        )
+
+    asset_url = signed_item.assets[asset].href
+    ds = rxr.open_rasterio(asset_url)
+
+    if as_cog:
+        kwargs["driver"] = "COG"  # Ensure the output is a Cloud Optimized GeoTIFF
+
+    if output:
+        print(f"Saving asset '{asset}' to {output}...")
+        ds.rio.to_raster(output, **kwargs)
+        print(f"Asset '{asset}' saved successfully.")
+    return ds
+
+
+def view_pc_item(
+    url=None,
+    collection=None,
+    item=None,
+    assets=None,
+    bands=None,
+    titiler_endpoint=None,
+    name="STAC Item",
+    attribution="Planetary Computer",
+    opacity=1.0,
+    shown=True,
+    fit_bounds=True,
+    layer_index=None,
+    backend="folium",
+    basemap=None,
+    map_args=None,
+    **kwargs,
+):
+
+    if backend == "folium":
+        import leafmap.foliumap as leafmap
+
+    elif backend == "ipyleaflet":
+        import leafmap.leafmap as leafmap
+
+    else:
+        raise ValueError(
+            f"Unsupported backend: {backend}. Supported backends are 'folium' and 'ipyleaflet'."
+        )
+
+    if map_args is None:
+        map_args = {}
+
+    if "draw_control" not in map_args:
+        map_args["draw_control"] = False
+
+    if url is not None:
+
+        item = pystac.Item.from_file(url)
+
+    if isinstance(item, pystac.Item):
+        collection = item.collection_id
+        if assets is None:
+            assets = [list(item.assets.keys())[0]]
+        item = item.id
+
+    m = leafmap.Map(**map_args)
+    if basemap is not None:
+        m.add_basemap(basemap)
+    m.add_stac_layer(
+        collection=collection,
+        item=item,
+        assets=assets,
+        bands=bands,
+        titiler_endpoint=titiler_endpoint,
+        name=name,
+        attribution=attribution,
+        opacity=opacity,
+        shown=shown,
+        fit_bounds=fit_bounds,
+        layer_index=layer_index,
+        **kwargs,
+    )
+    return m

geoai/extract.py

@@ -19,6 +19,7 @@ from torchvision.models.detection import (
     maskrcnn_resnet50_fpn,
 )
 from tqdm import tqdm
+import time
 
 # Local Imports
 from .utils import get_raster_stats
@@ -2117,6 +2118,7 @@ class ObjectDetector:
         confidence_threshold=0.5,
         min_object_area=100,
         max_object_area=None,
+        n_workers=None,
         **kwargs,
     ):
         """
@@ -2128,14 +2130,103 @@ class ObjectDetector:
             confidence_threshold: Minimum confidence score (0.0-1.0). Default: 0.5
             min_object_area: Minimum area in pixels to keep an object. Default: 100
             max_object_area: Maximum area in pixels to keep an object. Default: None
+            n_workers: int, default=None
+                The number of worker threads to use.
+                "None" means single-threaded processing.
+                "-1"   means using all available CPU processors.
+                Positive integer means using that specific number of threads.
             **kwargs: Additional parameters
 
         Returns:
             GeoDataFrame with car detections and confidence values
         """
 
+        def _process_single_component(
+            component_mask,
+            conf_data,
+            transform,
+            confidence_threshold,
+            min_object_area,
+            max_object_area,
+        ):
+            # Get confidence value
+            conf_region = conf_data[component_mask > 0]
+            if len(conf_region) > 0:
+                confidence = np.mean(conf_region) / 255.0
+            else:
+                confidence = 0.0
+
+            # Skip if confidence is below threshold
+            if confidence < confidence_threshold:
+                return None
+
+            # Find contours
+            contours, _ = cv2.findContours(
+                component_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+            )
+
+            results = []
+
+            for contour in contours:
+                # Filter by size
+                area = cv2.contourArea(contour)
+                if area < min_object_area:
+                    continue
+
+                if max_object_area is not None and area > max_object_area:
+                    continue
+
+                # Get minimum area rectangle
+                rect = cv2.minAreaRect(contour)
+                box_points = cv2.boxPoints(rect)
+
+                # Convert to geographic coordinates
+                geo_points = []
+                for x, y in box_points:
+                    gx, gy = transform * (x, y)
+                    geo_points.append((gx, gy))
+
+                # Create polygon
+                poly = Polygon(geo_points)
+                results.append((poly, confidence, area))
+
+            return results
+
+        import concurrent.futures
+        from functools import partial
+
+        def process_component(args):
+            """
+            Helper function to process a single component
+            """
+            (
+                label,
+                labeled_mask,
+                conf_data,
+                transform,
+                confidence_threshold,
+                min_object_area,
+                max_object_area,
+            ) = args
+
+            # Create mask for this component
+            component_mask = (labeled_mask == label).astype(np.uint8)
+
+            return _process_single_component(
+                component_mask,
+                conf_data,
+                transform,
+                confidence_threshold,
+                min_object_area,
+                max_object_area,
+            )
+
+        start_time = time.time()
         print(f"Processing masks from: {masks_path}")
 
+        if n_workers == -1:
+            n_workers = os.cpu_count()
+
         with rasterio.open(masks_path) as src:
             # Read mask and confidence bands
             mask_data = src.read(1)
@@ -2155,56 +2246,68 @@ class ObjectDetector:
             confidences = []
             pixels = []
 
-            # Add progress bar
-            for label in tqdm(range(1, num_features + 1), desc="Processing components"):
-                # Create mask for this component
-                component_mask = (labeled_mask == label).astype(np.uint8)
-
-                # Get confidence value (mean of non-zero values in this region)
-                conf_region = conf_data[component_mask > 0]
-                if len(conf_region) > 0:
-                    confidence = (
-                        np.mean(conf_region) / 255.0
-                    )  # Convert back to 0-1 range
-                else:
-                    confidence = 0.0
-
-                # Skip if confidence is below threshold
-                if confidence < confidence_threshold:
-                    continue
-
-                # Find contours
-                contours, _ = cv2.findContours(
-                    component_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+            if n_workers is None or n_workers == 1:
+                print(
+                    "Using single-threaded processing, you can speed up processing by setting n_workers > 1"
                 )
+                # Add progress bar
+                for label in tqdm(
+                    range(1, num_features + 1), desc="Processing components"
+                ):
+                    # Create mask for this component
+                    component_mask = (labeled_mask == label).astype(np.uint8)
+
+                    result = _process_single_component(
+                        component_mask,
+                        conf_data,
+                        transform,
+                        confidence_threshold,
+                        min_object_area,
+                        max_object_area,
+                    )
 
-                for contour in contours:
-                    # Filter by size
-                    area = cv2.contourArea(contour)
-                    if area < min_object_area:
-                        continue
-
-                    if max_object_area is not None:
-                        if area > max_object_area:
-                            continue
-
-                    # Get minimum area rectangle
-                    rect = cv2.minAreaRect(contour)
-                    box_points = cv2.boxPoints(rect)
+                    if result:
+                        for poly, confidence, area in result:
+                            # Add to lists
+                            polygons.append(poly)
+                            confidences.append(confidence)
+                            pixels.append(area)
 
-                    # Convert to geographic coordinates
-                    geo_points = []
-                    for x, y in box_points:
-                        gx, gy = transform * (x, y)
-                        geo_points.append((gx, gy))
-
-                    # Create polygon
-                    poly = Polygon(geo_points)
+            else:
+                # Process components in parallel
+                print(f"Using {n_workers} workers for parallel processing")
+
+                process_args = [
+                    (
+                        label,
+                        labeled_mask,
+                        conf_data,
+                        transform,
+                        confidence_threshold,
+                        min_object_area,
+                        max_object_area,
+                    )
+                    for label in range(1, num_features + 1)
+                ]
+
+                with concurrent.futures.ThreadPoolExecutor(
+                    max_workers=n_workers
+                ) as executor:
+                    results = list(
+                        tqdm(
+                            executor.map(process_component, process_args),
+                            total=num_features,
+                            desc="Processing components",
+                        )
+                    )
 
-                    # Add to lists
-                    polygons.append(poly)
-                    confidences.append(confidence)
-                    pixels.append(area)
+                    for result in results:
+                        if result:
+                            for poly, confidence, area in result:
+                                # Add to lists
+                                polygons.append(poly)
+                                confidences.append(confidence)
+                                pixels.append(area)
 
             # Create GeoDataFrame
             if polygons:
@@ -2223,8 +2326,12 @@ class ObjectDetector:
                     gdf.to_file(output_path, driver="GeoJSON")
                     print(f"Saved {len(gdf)} objects with confidence to {output_path}")
 
+                end_time = time.time()
+                print(f"Total processing time: {end_time - start_time:.2f} seconds")
                 return gdf
             else:
+                end_time = time.time()
+                print(f"Total processing time: {end_time - start_time:.2f} seconds")
                 print("No valid polygons found")
                 return None
 

geoai/geoai.py

@@ -1,15 +1,28 @@
 """Main module."""
 
+import leafmap
+
 from .download import (
     download_naip,
     download_overture_buildings,
     download_pc_stac_item,
     pc_collection_list,
+    pc_item_asset_list,
     pc_stac_search,
     pc_stac_download,
+    read_pc_item_asset,
+    view_pc_item,
 )
 from .extract import *
 from .hf import *
 from .segment import *
 from .train import object_detection, train_MaskRCNN_model
 from .utils import *
+
+
+class Map(leafmap.Map):
+    """A subclass of leafmap.Map for GeoAI applications."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the Map class."""
+        super().__init__(*args, **kwargs)

{geoai_py-0.4.2.dist-info → geoai_py-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.4.2
+Version: 0.4.3
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License

geoai_py-0.4.3.dist-info/RECORD

@@ -0,0 +1,15 @@
+geoai/__init__.py,sha256=b12E2HztHEPaaKMVKpk6GPjC7ElUMxOW9pYKl4VZkmE,3592
+geoai/download.py,sha256=BvCEpcBwZlEOWieixsdyvQDiE0CXRjU7oayLmy5_Dgs,40110
+geoai/extract.py,sha256=GocJufMmrwEWxNBL1J91EXXHL8AKcO8m_lmtUF5AKPw,119102
+geoai/geoai.py,sha256=BqKdWzNruDdGqwqoyTaJzUq4lKGj-RDBZlSO3t3-GxQ,626
+geoai/hf.py,sha256=mLKGxEAS5eHkxZLwuLpYc1o7e3-7QIXdBv-QUY-RkFk,17072
+geoai/segment.py,sha256=g3YW17ftr--CKq6VB32TJEPY8owGQ7uQ0sg_tUT2ooE,13681
+geoai/segmentation.py,sha256=AtPzCvguHAEeuyXafa4bzMFATvltEYcah1B8ZMfkM_s,11373
+geoai/train.py,sha256=-l2j1leTxDnFDLaBslu1q6CobXjm3LEdiQwUWOU8P6M,40088
+geoai/utils.py,sha256=Wg9jbMBKUZSGUmU8Vkp6v19QcDNg5KmcyZxuHqJvgnc,233016
+geoai_py-0.4.3.dist-info/licenses/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
+geoai_py-0.4.3.dist-info/METADATA,sha256=geDmJ-1zHImsOdcj4gypgq8JqSy8MznnxAnICwh0EbA,6049
+geoai_py-0.4.3.dist-info/WHEEL,sha256=aoLN90hLOL0c0qxXMxWYUM3HA3WmFGZQqEJHX1V_OJE,109
+geoai_py-0.4.3.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.4.3.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.4.3.dist-info/RECORD,,

{geoai_py-0.4.2.dist-info → geoai_py-0.4.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.1)
+Generator: setuptools (77.0.3)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

geoai_py-0.4.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-geoai/__init__.py,sha256=kHB6b3uOdCoxMpIpfpXtPxg-KJQVsKJveb8zTw5Mxzs,3592
-geoai/download.py,sha256=SE81OrhH2XSH02xtAXQyh5ltBqA8K7ksGT1Lm6SMqx8,37593
-geoai/extract.py,sha256=bR8TkUXncW0rinsBO5oxlVFGsSVoj6xnm5xdDc-J1Xk,115490
-geoai/geoai.py,sha256=qY1HWmJQ0ZgIPtlgWd4gpuCGw6dovdg8D5pAtHqfr8U,334
-geoai/hf.py,sha256=mLKGxEAS5eHkxZLwuLpYc1o7e3-7QIXdBv-QUY-RkFk,17072
-geoai/segment.py,sha256=g3YW17ftr--CKq6VB32TJEPY8owGQ7uQ0sg_tUT2ooE,13681
-geoai/segmentation.py,sha256=AtPzCvguHAEeuyXafa4bzMFATvltEYcah1B8ZMfkM_s,11373
-geoai/train.py,sha256=-l2j1leTxDnFDLaBslu1q6CobXjm3LEdiQwUWOU8P6M,40088
-geoai/utils.py,sha256=Wg9jbMBKUZSGUmU8Vkp6v19QcDNg5KmcyZxuHqJvgnc,233016
-geoai_py-0.4.2.dist-info/licenses/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.4.2.dist-info/METADATA,sha256=Sc6m-MyCti-_Dnan5wp6GIy88LwuBAF_IYrFF34SRJE,6049
-geoai_py-0.4.2.dist-info/WHEEL,sha256=9bhjOwO--Rs91xaPcBdlYFUmIudhuXqFlPriQeYQITw,109
-geoai_py-0.4.2.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.4.2.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.4.2.dist-info/RECORD,,