geoai-py 0.8.1__tar.gz → 0.8.2__tar.gz

{geoai_py-0.8.1 → geoai_py-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.8.1
+Version: 0.8.2
 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.8.1 → geoai_py-0.8.2}/docs/examples/building_detection_lidar.ipynb

@@ -10,9 +10,9 @@
    "source": [
     "# Building Detection from Aerial Imagery and LiDAR Data\n",
     "\n",
-    "[![image](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/opengeos/geoai/blob/main/docs/examples/building_detection_LiDAR.ipynb)\n",
+    "[![image](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/opengeos/geoai/blob/main/docs/examples/building_detection_lidar.ipynb)\n",
     "\n",
-    "This notebook demonstrates how to train semantic segmentation models for building detection from [NAIP aerial imagery](https://planetarycomputer.microsoft.com/dataset/naip) and [height above ground (HAG)](https://planetarycomputer.microsoft.com/dataset/3dep-LiDAR-hag) data derived from LiDAR data with just a few lines of code. You can adapt this notebook to segment other objects of interest (such as trees, cars, etc.) from aerial imagery and LiDAR data.\n",
+    "This notebook demonstrates how to train semantic segmentation models for building detection from [NAIP aerial imagery](https://planetarycomputer.microsoft.com/dataset/naip) and [height above ground (HAG)](https://planetarycomputer.microsoft.com/dataset/3dep-lidar-hag) data derived from LiDAR data with just a few lines of code. You can adapt this notebook to segment other objects of interest (such as trees, cars, etc.) from aerial imagery and LiDAR data.\n",
     "\n",
     "## Install packages\n",
     "\n",
@@ -45,6 +45,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import os\n",
     "import geoai"
    ]
   },
@@ -100,6 +101,15 @@
     "Visualize the building footprints with the aerial imagery."
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"TITILER_ENDPOINT\"] = \"https://titiler.xyz\""
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

geoai_py-0.8.2/docs/examples/water_detection_s2.ipynb

@@ -0,0 +1,297 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "# Water Detection with Sentinel-2 Imagery\n",
+    "\n",
+    "[![image](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/opengeos/geoai/blob/main/docs/examples/water_detection_s2.ipynb)\n",
+    "\n",
+    "This notebook demonstrates how to train semantic segmentation models for water detection using Sentinel-2 imagery.\n",
+    "\n",
+    "## Install packages\n",
+    "\n",
+    "To use the new functionality, ensure the required packages are installed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# %pip install geoai-py"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "## Import libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import geoai"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "## Download sample data\n",
+    "\n",
+    "We'll use the [Earth Surface Water Dataset](https://zenodo.org/records/5205674#.Y4iEFezP1hE) from Zenodo. Credits to the author (Xin Luo) of the dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "url = \"https://zenodo.org/records/5205674/files/dset-s2.zip?download=1\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_dir = geoai.download_file(url)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images_dir = f\"{data_dir}/dset-s2/tra_scene\"\n",
+    "masks_dir = f\"{data_dir}/dset-s2/tra_truth\"\n",
+    "tiles_dir = f\"{data_dir}/dset-s2/tiles\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create training data\n",
+    "\n",
+    "We'll create the same training tiles as before."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = geoai.export_geotiff_tiles_batch(\n",
+    "    images_folder=images_dir,\n",
+    "    masks_folder=masks_dir,\n",
+    "    output_folder=tiles_dir,\n",
+    "    tile_size=512,\n",
+    "    stride=128,\n",
+    "    quiet=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "## Train semantic segmentation model\n",
+    "\n",
+    "Now we'll train a semantic segmentation model using the new `train_segmentation_model` function. This function supports various architectures from `segmentation-models-pytorch`:\n",
+    "\n",
+    "- **Architectures**: `unet`, `unetplusplus` `deeplabv3`, `deeplabv3plus`, `fpn`, `pspnet`, `linknet`, `manet`\n",
+    "- **Encoders**: `resnet34`, `resnet50`, `efficientnet-b0`, `mobilenet_v2`, etc.\n",
+    "\n",
+    "For more details, please refer to the [segmentation-models-pytorch documentation](https://smp.readthedocs.io/en/latest/models.html).\n",
+    "\n",
+    "Let's train the module using U-Net with ResNet34 encoder:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test train_segmentation_model with automatic size detection\n",
+    "geoai.train_segmentation_model(\n",
+    "    images_dir=f\"{tiles_dir}/images\",\n",
+    "    labels_dir=f\"{tiles_dir}/masks\",\n",
+    "    output_dir=f\"{tiles_dir}/unet_models\",\n",
+    "    architecture=\"unet\",\n",
+    "    encoder_name=\"resnet34\",\n",
+    "    encoder_weights=\"imagenet\",\n",
+    "    num_channels=6,\n",
+    "    num_classes=2,  # background and water\n",
+    "    batch_size=8,\n",
+    "    num_epochs=50,\n",
+    "    learning_rate=0.001,\n",
+    "    val_split=0.2,\n",
+    "    verbose=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Evaluate the model\n",
+    "\n",
+    "Let's examine the training curves and model performance:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "geoai.plot_performance_metrics(\n",
+    "    history_path=f\"{tiles_dir}/unet_models/training_history.pth\",\n",
+    "    figsize=(15, 5),\n",
+    "    verbose=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![image](https://github.com/user-attachments/assets/61f675a7-ee67-4650-81c0-f754fe681f4d)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images_dir = f\"{data_dir}/dset-s2/val_scene\"\n",
+    "masks_dir = f\"{data_dir}/dset-s2/val_truth\"\n",
+    "predictions_dir = f\"{data_dir}/dset-s2/predictions\"\n",
+    "model_path = f\"{tiles_dir}/unet_models/best_model.pth\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "geoai.semantic_segmentation_batch(\n",
+    "    input_dir=images_dir,\n",
+    "    output_dir=predictions_dir,\n",
+    "    model_path=model_path,\n",
+    "    architecture=\"unet\",\n",
+    "    encoder_name=\"resnet34\",\n",
+    "    num_channels=6,\n",
+    "    num_classes=2,\n",
+    "    window_size=512,\n",
+    "    overlap=256,\n",
+    "    batch_size=8,\n",
+    "    quiet=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_image_path = (\n",
+    "    f\"{data_dir}/dset-s2/val_scene/S2A_L2A_20190318_N0211_R061_6Bands_S2.tif\"\n",
+    ")\n",
+    "ground_truth_path = (\n",
+    "    f\"{data_dir}/dset-s2/val_truth/S2A_L2A_20190318_N0211_R061_S2_Truth.tif\"\n",
+    ")\n",
+    "prediction_path = (\n",
+    "    f\"{data_dir}/dset-s2/predictions/S2A_L2A_20190318_N0211_R061_6Bands_S2_mask.tif\"\n",
+    ")\n",
+    "save_path = f\"{data_dir}/dset-s2/S2A_L2A_20190318_N0211_R061_6Bands_S2_comparison.png\"\n",
+    "\n",
+    "fig = geoai.plot_prediction_comparison(\n",
+    "    original_image=test_image_path,\n",
+    "    prediction_image=prediction_path,\n",
+    "    ground_truth_image=ground_truth_path,\n",
+    "    titles=[\"Original\", \"Prediction\", \"Ground Truth\"],\n",
+    "    figsize=(15, 5),\n",
+    "    save_path=save_path,\n",
+    "    show_plot=True,\n",
+    "    indexes=[5, 4, 3],\n",
+    "    divider=5000,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![image](https://github.com/user-attachments/assets/53601ed7-2bd6-4e7e-b369-4d7bfc2ce120)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "geo",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

{geoai_py-0.8.1 → geoai_py-0.8.2}/geoai/__init__.py

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

{geoai_py-0.8.1 → geoai_py-0.8.2}/geoai/utils.py

@@ -7280,105 +7280,123 @@ def plot_prediction_comparison(
     prediction_colormap: str = "gray",
     ground_truth_colormap: str = "gray",
     original_colormap: Optional[str] = None,
+    indexes: Optional[List[int]] = None,
+    divider: Optional[float] = None,
 ):
-    """
-    Plot original image, prediction image, and optionally ground truth image side by side.
+    """Plot original image, prediction, and optional ground truth side by side.
+
+    Supports input as file paths, NumPy arrays, or PIL Images. For multi-band
+    images, selected channels can be specified via `indexes`. If the image data
+    is not normalized (e.g., Sentinel-2 [0, 10000]), the `divider` can be used
+    to scale values for visualization.
 
     Args:
-        original_image: Original input image (file path, numpy array, or PIL Image)
-        prediction_image: Prediction/segmentation mask (file path, numpy array, or PIL Image)
-        ground_truth_image: Optional ground truth mask (file path, numpy array, or PIL Image)
-        titles: Optional list of titles for each subplot
-        figsize: Figure size tuple (width, height)
-        save_path: Optional path to save the plot
-        show_plot: Whether to display the plot
-        prediction_colormap: Colormap for prediction image
-        ground_truth_colormap: Colormap for ground truth image
-        original_colormap: Colormap for original image (None for RGB)
+        original_image (Union[str, np.ndarray, Image.Image]):
+            Original input image as a file path, NumPy array, or PIL Image.
+        prediction_image (Union[str, np.ndarray, Image.Image]):
+            Predicted segmentation mask image.
+        ground_truth_image (Optional[Union[str, np.ndarray, Image.Image]], optional):
+            Ground truth mask image. Defaults to None.
+        titles (Optional[List[str]], optional):
+            List of titles for the subplots. If not provided, default titles are used.
+        figsize (Tuple[int, int], optional):
+            Size of the entire figure in inches. Defaults to (15, 5).
+        save_path (Optional[str], optional):
+            If specified, saves the figure to this path. Defaults to None.
+        show_plot (bool, optional):
+            Whether to display the figure using plt.show(). Defaults to True.
+        prediction_colormap (str, optional):
+            Colormap to use for the prediction mask. Defaults to "gray".
+        ground_truth_colormap (str, optional):
+            Colormap to use for the ground truth mask. Defaults to "gray".
+        original_colormap (Optional[str], optional):
+            Colormap to use for the original image if it's grayscale. Defaults to None.
+        indexes (Optional[List[int]], optional):
+            List of band/channel indexes (0-based for NumPy, 1-based for rasterio) to extract from the original image.
+            Useful for multi-band imagery like Sentinel-2. Defaults to None.
+        divider (Optional[float], optional):
+            Value to divide the original image by for normalization (e.g., 10000 for reflectance). Defaults to None.
 
     Returns:
-        matplotlib.figure.Figure: The figure object
+        matplotlib.figure.Figure:
+            The generated matplotlib figure object.
     """
 
-    def _load_image(img_input):
+    def _load_image(img_input, indexes=None):
         """Helper function to load image from various input types."""
         if isinstance(img_input, str):
-            # File path
             if img_input.lower().endswith((".tif", ".tiff")):
-                # Handle GeoTIFF files
                 with rasterio.open(img_input) as src:
-                    img = src.read()
-                    if img.shape[0] == 1:
-                        # Single band
-                        img = img[0]
+                    if indexes:
+                        img = src.read(indexes)  # 1-based
+                        img = (
+                            np.transpose(img, (1, 2, 0)) if len(indexes) > 1 else img[0]
+                        )
                     else:
-                        # Multi-band, transpose to (H, W, C)
-                        img = np.transpose(img, (1, 2, 0))
+                        img = src.read()
+                        if img.shape[0] == 1:
+                            img = img[0]
+                        else:
+                            img = np.transpose(img, (1, 2, 0))
             else:
-                # Regular image file
                 img = np.array(Image.open(img_input))
         elif isinstance(img_input, Image.Image):
-            # PIL Image
             img = np.array(img_input)
         elif isinstance(img_input, np.ndarray):
-            # NumPy array
             img = img_input
+            if indexes is not None and img.ndim == 3:
+                img = img[:, :, indexes]
         else:
             raise ValueError(f"Unsupported image type: {type(img_input)}")
-
         return img
 
     # Load images
-    original = _load_image(original_image)
+    original = _load_image(original_image, indexes=indexes)
     prediction = _load_image(prediction_image)
     ground_truth = (
         _load_image(ground_truth_image) if ground_truth_image is not None else None
     )
 
-    # Determine number of subplots
-    num_plots = 3 if ground_truth is not None else 2
+    # Apply divider normalization if requested
+    if divider is not None and isinstance(original, np.ndarray) and original.ndim == 3:
+        original = np.clip(original.astype(np.float32) / divider, 0, 1)
 
-    # Create figure and subplots
+    # Determine layout
+    num_plots = 3 if ground_truth is not None else 2
     fig, axes = plt.subplots(1, num_plots, figsize=figsize)
     if num_plots == 2:
         axes = [axes[0], axes[1]]
 
-    # Default titles
     if titles is None:
         titles = ["Original Image", "Prediction"]
         if ground_truth is not None:
             titles.append("Ground Truth")
 
-    # Plot original image
-    if len(original.shape) == 3 and original.shape[2] in [3, 4]:
-        # RGB or RGBA image
+    # Plot original
+    if original.ndim == 3 and original.shape[2] in [3, 4]:
         axes[0].imshow(original)
     else:
-        # Grayscale or single channel
         axes[0].imshow(original, cmap=original_colormap)
     axes[0].set_title(titles[0])
     axes[0].axis("off")
 
-    # Plot prediction image
+    # Prediction
     axes[1].imshow(prediction, cmap=prediction_colormap)
     axes[1].set_title(titles[1])
     axes[1].axis("off")
 
-    # Plot ground truth if provided
+    # Ground truth
     if ground_truth is not None:
         axes[2].imshow(ground_truth, cmap=ground_truth_colormap)
         axes[2].set_title(titles[2])
         axes[2].axis("off")
 
-    # Adjust layout
     plt.tight_layout()
 
-    # Save if requested
     if save_path:
         plt.savefig(save_path, dpi=300, bbox_inches="tight")
         print(f"Plot saved to: {save_path}")
 
-    # Show plot
     if show_plot:
         plt.show()
 

{geoai_py-0.8.1 → geoai_py-0.8.2}/geoai_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.8.1
+Version: 0.8.2
 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.8.1 → geoai_py-0.8.2}/geoai_py.egg-info/SOURCES.txt

@@ -80,6 +80,7 @@ docs/examples/train_solar_panel_detection.ipynb
 docs/examples/train_water_detection.ipynb
 docs/examples/view_metadata.ipynb
 docs/examples/water_detection.ipynb
+docs/examples/water_detection_s2.ipynb
 docs/examples/water_dynamics.ipynb
 docs/examples/wetland_mapping.ipynb
 docs/examples/dataviz/lidar_viz.ipynb

{geoai_py-0.8.1 → geoai_py-0.8.2}/mkdocs.yml

@@ -137,6 +137,7 @@ nav:
           - examples/grounded_sam.ipynb
           - examples/load_model_checkpoint.ipynb
           - examples/water_detection.ipynb
+          - examples/water_detection_s2.ipynb
           - examples/batch_segmentation.ipynb
           - examples/building_detection_lidar.ipynb
           #   - examples/samgeo/satellite.ipynb

{geoai_py-0.8.1 → geoai_py-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "geoai-py"
-version = "0.8.1"
+version = "0.8.2"
 dynamic = [
     "dependencies",
 ]
@@ -43,7 +43,7 @@ universal = true
 
 
 [tool.bumpversion]
-current_version = "0.8.1"
+current_version = "0.8.2"
 commit = true
 tag = true