geoai-py 0.19.0__tar.gz → 0.20.0__tar.gz

{geoai_py-0.19.0 → geoai_py-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.19.0
+Version: 0.20.0
 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.19.0 → geoai_py-0.20.0}/geoai/__init__.py

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

{geoai_py-0.19.0 → geoai_py-0.20.0}/geoai_py.egg-info/PKG-INFO

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

@@ -49,6 +49,23 @@ geoai_py.egg-info/dependency_links.txt
 geoai_py.egg-info/entry_points.txt
 geoai_py.egg-info/requires.txt
 geoai_py.egg-info/top_level.txt
+qgis_plugin/README.md
+qgis_plugin/install.py
+qgis_plugin/install.sh
+qgis_plugin/geoai_plugin/__init__.py
+qgis_plugin/geoai_plugin/geoai_plugin.py
+qgis_plugin/geoai_plugin/metadata.txt
+qgis_plugin/geoai_plugin/dialogs/__init__.py
+qgis_plugin/geoai_plugin/dialogs/map_tools.py
+qgis_plugin/geoai_plugin/dialogs/moondream.py
+qgis_plugin/geoai_plugin/dialogs/samgeo.py
+qgis_plugin/geoai_plugin/dialogs/segmentation.py
+qgis_plugin/geoai_plugin/icons/about.svg
+qgis_plugin/geoai_plugin/icons/gpu.svg
+qgis_plugin/geoai_plugin/icons/icon.png
+qgis_plugin/geoai_plugin/icons/moondream.svg
+qgis_plugin/geoai_plugin/icons/samgeo.png
+qgis_plugin/geoai_plugin/icons/segment.svg
 tests/__init__.py
 tests/create_test_data.py
 tests/test_classify.py

{geoai_py-0.19.0 → geoai_py-0.20.0}/pyproject.toml

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

geoai_py-0.20.0/qgis_plugin/README.md

@@ -0,0 +1,188 @@
+# GeoAI Plugin for QGIS
+
+A QGIS plugin providing AI-powered geospatial analysis tools from the [geoai](https://github.com/opengeos/geoai) package.
+
+## Features
+
+The plugin provides **dockable panels** that can be attached to the left or right side of QGIS.
+
+### Moondream Vision-Language Model Panel
+- **Caption**: Generate descriptions of geospatial imagery (short, normal, or long)
+- **Query**: Ask questions about images using natural language
+- **Detect**: Detect and locate objects with bounding boxes
+- **Point**: Locate specific objects with point markers
+
+### Segmentation Panel (Combined Training & Inference)
+- **Tab 1 - Create Training Data**: Export GeoTIFF tiles from raster and vector data
+- **Tab 2 - Train Models**: Train custom segmentation models (U-Net, DeepLabV3+, FPN, etc.)
+- **Tab 3 - Run Inference**: Apply trained models to new imagery and vectorize results
+
+### SamGeo Panel (Segment Anything Model)
+- **Model Tab**: Load SAM models (SAM1, SAM2, or SAM3) with configurable backend and device settings
+- **Text Tab**: Segment objects using text prompts (e.g., "tree", "building", "road")
+- **Interactive Tab**: Segment using point prompts (foreground/background) or box prompts drawn on the map
+- **Batch Tab**: Process multiple points interactively or from vector files/layers
+- **Output Tab**: Save results as raster (GeoTIFF) or vector (GeoPackage, Shapefile) with optional regularization (orthogonalize polygons, filter by minimum area)
+
+### GPU Memory Management
+- **Clear GPU Memory**: Release GPU memory and clear CUDA cache for all loaded models
+
+## Requirements
+
+- QGIS 3.28 or later
+- Python 3.10+
+- PyTorch (with CUDA support for GPU acceleration)
+- geoai-py package
+- samgeo package (for SamGeo panel)
+
+## Installation
+
+### Option 1: Install from Plugin Manager (Recommended)
+
+1. Open QGIS
+2. Go to `Plugins` → `Manage and Install Plugins...`
+3. Search for "GeoAI"
+4. Click "Install Plugin"
+
+### Option 2: Install Using Script (Recommended for Developers)
+
+1. Clone or download this repository
+2. Run the installation script:
+
+   **Linux/macOS:**
+   ```bash
+   python install.py
+   ```
+
+   **Windows:**
+   ```cmd
+   python install.py
+   ```
+
+3. Restart QGIS
+4. Enable the plugin in `Plugins` → `Manage and Install Plugins...`
+
+To remove the plugin:
+```bash
+python install.py --remove
+```
+
+### Option 3: Manual Installation
+
+1. Copy the `geoai_plugin` folder to your QGIS plugins directory:
+   - **Linux**: `~/.local/share/QGIS/QGIS3/profiles/default/python/plugins/`
+   - **Windows**: `C:\Users\<username>\AppData\Roaming\QGIS\QGIS3\profiles\default\python\plugins\`
+   - **macOS**: `~/Library/Application Support/QGIS/QGIS3/profiles/default/python/plugins/`
+2. Restart QGIS
+3. Enable the plugin in `Plugins` → `Manage and Install Plugins...`
+
+### Install Dependencies
+
+Before using the plugin, install the required Python packages in your QGIS Python environment:
+
+```bash
+conda create -n geo python=3.12
+conda activate geo
+conda install -c conda-forge qgis segment-geospatial geoai
+```
+
+Some SamGeo dependencies are only available on PyPI. Run the following command to install all dependencies:
+
+```bash
+pip install -U "segment-geospatial[samgeo3]"
+```
+
+It is a bit tricky to install SAM 3 on Windows. Run the following commands on Windows to install SamGeo:
+
+```bash
+conda create -n geo python=3.12
+conda activate geo
+conda install pytorch torchvision pytorch-cuda=12.1 -c pytorch -c nvidia
+conda install -c conda-forge qgis segment-geospatial geoai
+pip install "segment-geospatial[samgeo3]" triton-windows
+```
+
+## Usage
+
+### Moondream Vision-Language Model
+
+1. Click the **Moondream** button in the GeoAI toolbar (or `GeoAI` menu → `Moondream VLM`)
+2. Load a Moondream model (default: vikhyatk/moondream2)
+3. Select a raster layer or browse for an image file
+4. Choose a mode:
+   - **Caption**: Generate a description of the image
+   - **Query**: Ask a question about the image
+   - **Detect**: Detect objects by type (e.g., "building", "car")
+   - **Point**: Locate specific objects
+5. Click "Run Analysis"
+6. Results are displayed and optionally added to the map
+
+### Segmentation Panel (Create Data, Train, Inference)
+
+1. Click the **Segmentation** button in the GeoAI toolbar (or `GeoAI` menu → `Segmentation`)
+2. Use the tabs at the top of the panel to switch between:
+   - **Create Training Data**: Select input raster and vector labels, configure tile size and stride, and export tiles to a directory.
+   - **Train Model**: Select the images and labels directories, choose model architecture (U-Net, DeepLabV3+, etc.), configure training parameters, and start training.
+   - **Run Inference**: Select input raster layer or file, specify the trained model path, configure inference parameters, run inference, and optionally vectorize the results.
+
+### SamGeo Panel (Segment Anything Model)
+
+1. Click the **SamGeo** button in the GeoAI toolbar (or `GeoAI` menu → `SamGeo`)
+2. In the **Model** tab:
+   - Select the SAM model version (SamGeo3/SAM3, SamGeo2/SAM2, or SamGeo/SAM1)
+   - Configure backend (meta or transformers) and device (auto, cuda, cpu)
+   - Click "Load Model" to initialize the model
+   - Select a raster layer or browse for an image file and click "Set Image"
+3. Choose a segmentation method:
+   - **Text Tab**: Enter text prompts describing objects to segment (e.g., "tree, building")
+   - **Interactive Tab**:
+     - Click "Add Foreground Points" or "Add Background Points" and click on the map
+     - Or click "Draw Box" and drag a rectangle on the map
+     - Click "Segment by Points" or "Segment by Box"
+   - **Batch Tab**: Add multiple points interactively or load from a vector file/layer
+4. In the **Output** tab:
+   - Select output format (Raster GeoTIFF, Vector GeoPackage, or Vector Shapefile)
+   - For vector output, optionally enable regularization:
+     - Check "Regularize polygons (orthogonalize)"
+     - Set Epsilon (simplification tolerance) and Min Area (filter small polygons)
+   - Click "Save Masks" to export results
+
+### Clear GPU Memory
+
+Click the **GPU** button in the GeoAI toolbar to release GPU memory from all loaded models (Moondream, SamGeo, etc.) and clear CUDA cache.
+
+## Supported Model Architectures (Segmentation)
+
+- U-Net
+- U-Net++
+- DeepLabV3
+- DeepLabV3+
+- FPN (Feature Pyramid Network)
+- PSPNet
+- LinkNet
+- MANet
+- SegFormer
+
+## Supported Encoders (Segmentation)
+
+- ResNet (34, 50, 101, 152)
+- EfficientNet (b0-b4)
+- MobileNetV2
+- VGG (16, 19)
+
+## Supported SAM Models (SamGeo)
+
+- **SamGeo3 (SAM3)**: Latest version with text prompts, point prompts, and box prompts
+- **SamGeo2 (SAM2)**: Improved version with better performance
+- **SamGeo (SAM1)**: Original Segment Anything Model
+
+## License
+
+MIT License - see [LICENSE](../LICENSE) for details.
+
+## Links
+
+- [GeoAI Documentation](https://opengeoai.org)
+- [SamGeo Documentation](https://samgeo.gishub.org)
+- [GitHub Repository](https://github.com/opengeos/geoai)
+- [Report Issues](https://github.com/opengeos/geoai/issues)

geoai_py-0.20.0/qgis_plugin/geoai_plugin/__init__.py

@@ -0,0 +1,21 @@
+"""
+GeoAI Plugin for QGIS
+
+This plugin provides AI-powered geospatial analysis tools including:
+- Moondream vision-language model for image analysis
+- Semantic segmentation model training and inference
+"""
+
+from .geoai_plugin import GeoAIPlugin
+
+
+def classFactory(iface):
+    """Load GeoAIPlugin class from file geoai_plugin.
+
+    Args:
+        iface: A QGIS interface instance.
+
+    Returns:
+        GeoAIPlugin: The plugin instance.
+    """
+    return GeoAIPlugin(iface)

geoai_py-0.20.0/qgis_plugin/geoai_plugin/dialogs/__init__.py

@@ -0,0 +1,13 @@
+"""
+GeoAI Plugin Dialogs
+
+This module contains the dialog and dock widget classes for the GeoAI plugin.
+"""
+
+from .moondream import MoondreamDockWidget
+from .segmentation import SegmentationDockWidget
+
+__all__ = [
+    "MoondreamDockWidget",
+    "SegmentationDockWidget",
+]

geoai_py-0.20.0/qgis_plugin/geoai_plugin/dialogs/map_tools.py

@@ -0,0 +1,172 @@
+"""
+Map tools for interactive segmentation prompts.
+"""
+
+from qgis.PyQt.QtCore import Qt, pyqtSignal
+from qgis.PyQt.QtGui import QColor
+from qgis.core import QgsPointXY, QgsRectangle, QgsWkbTypes
+from qgis.gui import QgsMapTool, QgsRubberBand, QgsVertexMarker
+
+
+class PointPromptTool(QgsMapTool):
+    """Map tool for adding point prompts."""
+
+    # Removed unused point_added signal
+
+    def __init__(self, canvas, plugin, batch_mode=False):
+        """Initialize the point prompt tool.
+
+        Args:
+            canvas: The QGIS map canvas.
+            plugin: The parent plugin instance.
+            batch_mode: If True, adds points to batch list instead of regular list.
+        """
+        super().__init__(canvas)
+        self.canvas = canvas
+        self.plugin = plugin
+        self.is_foreground = True
+        self.batch_mode = batch_mode
+        self.markers = []
+
+        # Set cursor
+        self.setCursor(Qt.CrossCursor)
+
+    def set_foreground(self, foreground):
+        """Set whether we're adding foreground or background points."""
+        self.is_foreground = foreground
+
+    def canvasPressEvent(self, event):
+        """Handle mouse press event."""
+        pass
+
+    def canvasReleaseEvent(self, event):
+        """Handle mouse release event - add a point."""
+        if event.button() == Qt.LeftButton:
+            point = self.toMapCoordinates(event.pos())
+
+            # Add visual marker
+            marker = QgsVertexMarker(self.canvas)
+            marker.setCenter(point)
+            # Use blue for batch mode, green/red for regular mode
+            if self.batch_mode:
+                marker.setColor(QColor(0, 120, 255))
+            else:
+                marker.setColor(
+                    QColor(0, 255, 0) if self.is_foreground else QColor(255, 0, 0)
+                )
+            marker.setIconType(QgsVertexMarker.ICON_CIRCLE)
+            marker.setIconSize(10)
+            marker.setPenWidth(3)
+            self.markers.append(marker)
+
+            # Add point to plugin
+            if self.batch_mode:
+                self.plugin.add_batch_point(point)
+            else:
+                self.plugin.add_point(point, self.is_foreground)
+
+        elif event.button() == Qt.RightButton:
+            # Right-click to finish
+            self.deactivate()
+            if self.batch_mode:
+                self.plugin.batch_add_point_btn.setChecked(False)
+            else:
+                self.plugin.add_fg_point_btn.setChecked(False)
+                self.plugin.add_bg_point_btn.setChecked(False)
+
+    def clear_markers(self):
+        """Clear all markers from the canvas."""
+        for marker in self.markers:
+            self.canvas.scene().removeItem(marker)
+        self.markers = []
+
+    def deactivate(self):
+        """Deactivate the tool."""
+        super().deactivate()
+
+
+class BoxPromptTool(QgsMapTool):
+    """Map tool for drawing box prompts."""
+
+    box_drawn = pyqtSignal(object)  # QgsRectangle
+
+    def __init__(self, canvas, plugin):
+        """Initialize the box prompt tool.
+
+        Args:
+            canvas: The QGIS map canvas.
+            plugin: The parent plugin instance.
+        """
+        super().__init__(canvas)
+        self.canvas = canvas
+        self.plugin = plugin
+
+        # Rubber band for visual feedback
+        self.rubber_band = QgsRubberBand(canvas, QgsWkbTypes.PolygonGeometry)
+        self.rubber_band.setColor(QColor(0, 120, 255, 100))
+        self.rubber_band.setStrokeColor(QColor(0, 120, 255))
+        self.rubber_band.setWidth(2)
+
+        self.start_point = None
+        self.is_drawing = False
+
+        # Set cursor
+        self.setCursor(Qt.CrossCursor)
+
+    def canvasPressEvent(self, event):
+        """Handle mouse press event - start drawing."""
+        if event.button() == Qt.LeftButton:
+            self.start_point = self.toMapCoordinates(event.pos())
+            self.is_drawing = True
+            self.rubber_band.reset(QgsWkbTypes.PolygonGeometry)
+
+    def canvasMoveEvent(self, event):
+        """Handle mouse move event - update rubber band."""
+        if self.is_drawing and self.start_point is not None:
+            current_point = self.toMapCoordinates(event.pos())
+            self.update_rubber_band(self.start_point, current_point)
+
+    def canvasReleaseEvent(self, event):
+        """Handle mouse release event - finish drawing."""
+        if event.button() == Qt.LeftButton and self.is_drawing:
+            end_point = self.toMapCoordinates(event.pos())
+            self.is_drawing = False
+
+            # Create rectangle
+            rect = QgsRectangle(self.start_point, end_point)
+
+            # Update rubber band with final position
+            self.update_rubber_band(self.start_point, end_point)
+
+            # Set box in plugin
+            self.plugin.set_box(rect)
+
+            # Deactivate tool
+            self.deactivate()
+            self.plugin.draw_box_btn.setChecked(False)
+
+        elif event.button() == Qt.RightButton:
+            # Right-click to cancel
+            self.is_drawing = False
+            self.rubber_band.reset(QgsWkbTypes.PolygonGeometry)
+            self.deactivate()
+            self.plugin.draw_box_btn.setChecked(False)
+
+    def update_rubber_band(self, start_point, end_point):
+        """Update the rubber band rectangle."""
+        self.rubber_band.reset(QgsWkbTypes.PolygonGeometry)
+
+        # Create rectangle points
+        self.rubber_band.addPoint(QgsPointXY(start_point.x(), start_point.y()), False)
+        self.rubber_band.addPoint(QgsPointXY(end_point.x(), start_point.y()), False)
+        self.rubber_band.addPoint(QgsPointXY(end_point.x(), end_point.y()), False)
+        self.rubber_band.addPoint(QgsPointXY(start_point.x(), end_point.y()), True)
+
+    def clear_rubber_band(self):
+        """Clear the rubber band."""
+        self.rubber_band.reset(QgsWkbTypes.PolygonGeometry)
+
+    def deactivate(self):
+        """Deactivate the tool."""
+        self.is_drawing = False
+        super().deactivate()