segment-geospatial 1.3.1__tar.gz → 1.3.3__tar.gz

{segment_geospatial-1.3.1 → segment_geospatial-1.3.3}/.github/workflows/docs-build.yml

@@ -14,7 +14,7 @@ jobs:
               with:
                   fetch-depth: 0
             - name: Setup micromamba
-              uses: mamba-org/setup-micromamba@v2
+              uses: mamba-org/setup-micromamba@v3
               with:
                   environment-name: docs-env
                   create-args: >-
@@ -34,7 +34,7 @@ jobs:
                   pip install .
             - run: mkdocs build
             - name: Deploy to Netlify
-              uses: nwtgck/actions-netlify@v3.0
+              uses: nwtgck/actions-netlify@v4.0
               with:
                   publish-dir: "./site"
                   production-branch: master

{segment_geospatial-1.3.1 → segment_geospatial-1.3.3}/.github/workflows/macos.yml

@@ -25,7 +25,7 @@ jobs:
             - uses: actions/checkout@v6
 
             - name: Setup micromamba
-              uses: mamba-org/setup-micromamba@v2
+              uses: mamba-org/setup-micromamba@v3
               with:
                   environment-name: test-env
                   create-args: >-

segment_geospatial-1.3.3/.github/workflows/publish.yml

@@ -0,0 +1,54 @@
+name: Publish
+
+on:
+    release:
+        types: [published]
+    workflow_dispatch:
+        inputs:
+            tag:
+                description: "Release tag to publish (must already exist on GitHub)"
+                required: true
+                type: string
+
+permissions:
+    contents: write
+
+jobs:
+    publish:
+        name: Publish plugin to plugins.qgis.org
+        runs-on: ubuntu-latest
+        env:
+            TAG: ${{ github.event.release.tag_name || inputs.tag }}
+            PLUGIN_DIR: qgis-samgeo-plugin
+            PLUGIN_NAME: samgeo_plugin
+            ZIP_PATH: dist/samgeo_plugin.zip
+        steps:
+            - uses: actions/checkout@v6
+
+            - uses: actions/setup-python@v6
+              with:
+                  python-version: "3.13"
+
+            - name: Build plugin zip
+              run: python "package_plugin.py" --source "$PLUGIN_DIR" --name "$PLUGIN_NAME" --output "$ZIP_PATH"
+
+            - name: Verify metadata version matches release tag
+              run: |
+                  metadata_version=$(grep '^version=' "$PLUGIN_DIR/metadata.txt" | cut -d'=' -f2 | tr -d '[:space:]')
+                  tag_version="${TAG#v}"
+                  if [ "$metadata_version" != "$tag_version" ]; then
+                      echo "::error::metadata.txt version ($metadata_version) does not match release tag ($tag_version)"
+                      exit 1
+                  fi
+
+            - name: Attach zip to GitHub release
+              env:
+                  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+              run: |
+                  gh release upload "$TAG" "$ZIP_PATH" --clobber
+
+            - name: Upload to plugins.qgis.org
+              env:
+                  QGIS_PLUGIN_REPO_USERNAME: ${{ secrets.QGIS_PLUGIN_REPO_USERNAME }}
+                  QGIS_PLUGIN_REPO_PASSWORD: ${{ secrets.QGIS_PLUGIN_REPO_PASSWORD }}
+              run: python scripts/upload_to_qgis_plugin_repo.py "$ZIP_PATH"

{segment_geospatial-1.3.1 → segment_geospatial-1.3.3}/.github/workflows/ubuntu.yml

@@ -28,7 +28,7 @@ jobs:
             - name: CHECKOUT CODE
               uses: actions/checkout@v6
             - name: Setup micromamba
-              uses: mamba-org/setup-micromamba@v2
+              uses: mamba-org/setup-micromamba@v3
               with:
                   environment-name: test-env
                   create-args: >-

{segment_geospatial-1.3.1 → segment_geospatial-1.3.3}/.github/workflows/windows.yml

@@ -16,7 +16,7 @@ jobs:
         steps:
             - uses: actions/checkout@v6
             - name: Setup micromamba
-              uses: mamba-org/setup-micromamba@v2
+              uses: mamba-org/setup-micromamba@v3
               with:
                   environment-name: test-env
                   create-args: >-

{segment_geospatial-1.3.1 → segment_geospatial-1.3.3}/.pre-commit-config.yaml

@@ -12,7 +12,7 @@ repos:
             args: ["--maxkb=500"]
 
     - repo: https://github.com/astral-sh/ruff-pre-commit
-      rev: v0.15.6
+      rev: v0.15.16
       hooks:
           - id: ruff
             types_or: [pyi, jupyter]

{segment_geospatial-1.3.1 → segment_geospatial-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: segment-geospatial
-Version: 1.3.1
+Version: 1.3.3
 Summary: Meta AI's Segment Anything Model (SAM) for Geospatial Data.
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT license

segment_geospatial-1.3.3/agent-harness/SAMGEO.md

@@ -0,0 +1,59 @@
+# SAMGEO: Agent Harness SOP
+
+## Software Overview
+
+**segment-geospatial** (samgeo) is a Python package for segmenting geospatial data
+using Meta AI's Segment Anything Model (SAM) family. It wraps SAM v1, SAM 2, SAM 3,
+FastSAM, HQ-SAM, and LangSAM with geospatial-aware I/O (GeoTIFF, GeoPackage, etc.).
+
+## Backend
+
+The backend is the `samgeo` Python library itself. Unlike GUI applications that need
+a headless CLI invocation, samgeo is already a Python library — the CLI harness imports
+and calls its classes/functions directly.
+
+**Key classes:**
+- `SamGeo` (v1) — `samgeo.samgeo.SamGeo`
+- `SamGeo2` (v2) — `samgeo.samgeo2.SamGeo2`
+- `SamGeo3` (v3) — `samgeo.samgeo3.SamGeo3`
+- `LangSAM` — `samgeo.text_sam.LangSAM`
+
+**Key utility functions** (from `samgeo.common`):
+- `tms_to_geotiff()` — Download TMS tiles as GeoTIFF
+- `raster_to_vector()` / `raster_to_gpkg()` / `raster_to_shp()` / `raster_to_geojson()`
+- `reproject()`, `split_raster()`, `image_to_cog()`
+- `get_profile()`, `get_basemaps()`
+
+## Data Model
+
+**Project state** is a JSON file tracking:
+- Source image path, CRS, bounds
+- Active model type and parameters
+- Generated mask paths
+- Vector output paths
+- Operation history (for undo/redo)
+
+**File formats:**
+- Input: GeoTIFF, PNG, JPG, NumPy arrays, URLs
+- Mask output: GeoTIFF (raster masks)
+- Vector output: GeoPackage (.gpkg), Shapefile (.shp), GeoJSON (.geojson)
+- Project: JSON (.json)
+
+## CLI Command Groups
+
+| Group | Purpose |
+|-------|---------|
+| `project` | Create, open, save, inspect projects |
+| `model` | List, download, inspect SAM models |
+| `segment` | Automatic, point, box, and text segmentation |
+| `data` | Download tiles, inspect rasters, reproject, split |
+| `vector` | Convert masks to vectors, inspect, filter |
+| `export` | Export masks and vectors to various formats |
+| `session` | Undo/redo, history, session state |
+
+## Dependencies
+
+- `segment-geospatial` (the package itself — hard dependency)
+- `click` (CLI framework)
+- `prompt_toolkit` (REPL)
+- PyTorch + SAM model weights (downloaded on first use)

segment_geospatial-1.3.3/agent-harness/cli_anything/samgeo/README.md

@@ -0,0 +1,148 @@
+# cli-anything-samgeo
+
+CLI harness for [segment-geospatial](https://github.com/opengeos/segment-geospatial) — segment geospatial imagery using SAM models from the command line.
+
+## Prerequisites
+
+- Python 3.10+
+- segment-geospatial: `pip install segment-geospatial[all]`
+- PyTorch with CUDA (recommended) or CPU
+
+## Installation
+
+```bash
+cd agent-harness
+pip install -e .
+```
+
+This installs the `cli-anything-samgeo` command in your PATH.
+
+## Quick Start
+
+```bash
+# Create a project
+cli-anything-samgeo project new -n my-seg -o project.json -s image.tif
+
+# Run automatic segmentation
+cli-anything-samgeo --project project.json segment automatic -o masks.tif
+
+# Convert masks to vectors
+cli-anything-samgeo --project project.json vector convert masks.tif output.gpkg
+
+# Export as GeoJSON
+cli-anything-samgeo --project project.json export render output.geojson -f geojson
+
+# All commands support --json for machine-readable output
+cli-anything-samgeo --json model list
+```
+
+## Command Groups
+
+| Command | Description |
+|---------|-------------|
+| `project` | Create, open, inspect projects |
+| `model` | List, inspect, check SAM models |
+| `segment` | Automatic, point, box, text segmentation |
+| `data` | Download tiles, raster info, reproject, split |
+| `vector` | Convert masks to vectors, inspect, filter |
+| `export` | Export masks to various formats |
+| `session` | Session status and history |
+
+## Interactive REPL
+
+Run without arguments to enter the interactive REPL:
+
+```bash
+cli-anything-samgeo
+```
+
+## JSON Output
+
+Add `--json` before any command for machine-readable output:
+
+```bash
+cli-anything-samgeo --json data info image.tif
+cli-anything-samgeo --json model list
+```
+
+## Using with Claude Code
+
+This CLI ships with a `SKILL.md` file that lets Claude Code discover and use all
+commands automatically. There are two ways to enable it.
+
+### Option 1: Add SKILL.md to your CLAUDE.md
+
+Append a reference to the skill file in your project or user `CLAUDE.md`:
+
+```markdown
+# In your CLAUDE.md
+Read the skill file at /path/to/agent-harness/cli_anything/samgeo/skills/SKILL.md
+for the full cli-anything-samgeo command reference. Use `--json` for all
+cli-anything-samgeo commands so output is machine-readable.
+```
+
+Replace `/path/to/` with the actual absolute path. Claude Code reads `CLAUDE.md`
+at the start of every conversation, so it will know the CLI exists and how to
+call it.
+
+### Option 2: Point Claude Code at the skill on the fly
+
+In any Claude Code conversation, paste:
+
+```
+Read agent-harness/cli_anything/samgeo/skills/SKILL.md and use that CLI
+to segment this satellite image.
+```
+
+Claude Code will read the skill file, learn the command syntax, and start
+using `cli-anything-samgeo` with `--json` output.
+
+### Example Claude Code session
+
+Once Claude Code knows about the skill, you can give it natural-language tasks:
+
+```
+> Segment all buildings in satellite.tif and export the results as a GeoPackage.
+
+# Claude Code will run:
+cli-anything-samgeo --json project new -n buildings -o project.json -s satellite.tif -t sam2
+cli-anything-samgeo --json --project project.json segment automatic -o masks.tif
+cli-anything-samgeo --json vector convert masks.tif buildings.gpkg
+```
+
+```
+> Download OpenStreetMap tiles for downtown Portland and tell me about the image.
+
+# Claude Code will run:
+cli-anything-samgeo --json data download-tiles -o portland.tif -b "-122.68,45.51,-122.66,45.53" -z 17
+cli-anything-samgeo --json data info portland.tif
+```
+
+### Tips for Claude Code usage
+
+- The `--json` flag is essential — it gives Claude Code structured output it can
+  parse and reason about, rather than human-formatted tables.
+- The `--project` flag must appear *before* the command group (e.g.,
+  `--project proj.json segment automatic`, not `segment automatic --project proj.json`).
+- Claude Code can chain multiple commands in sequence to build full pipelines
+  (download → segment → vectorize → export).
+- Use `model check sam2` to let Claude Code verify a model backend is installed
+  before attempting segmentation.
+
+## Running Tests
+
+```bash
+cd agent-harness
+python -m pytest cli_anything/samgeo/tests/ -v -s
+```
+
+## Supported Models
+
+| Type | Models | Install |
+|------|--------|---------|
+| SAM v1 | vit_h, vit_l, vit_b | `pip install segment-geospatial` |
+| SAM 2 | hiera-tiny/small/base-plus/large | `pip install segment-geospatial[samgeo2]` |
+| SAM 3 | facebook/sam3 | `pip install segment-geospatial[samgeo3]` |
+| FastSAM | FastSAM-x, FastSAM-s | `pip install segment-geospatial[fast]` |
+| HQ-SAM | vit_h, vit_l, vit_b, vit_tiny | `pip install segment-geospatial[hq]` |
+| LangSAM | text-based (SAM2 backend) | `pip install segment-geospatial[text]` |

segment_geospatial-1.3.3/agent-harness/cli_anything/samgeo/__init__.py

@@ -0,0 +1,3 @@
+"""cli-anything-samgeo: CLI harness for segment-geospatial."""
+
+__version__ = "0.1.0"

segment_geospatial-1.3.3/agent-harness/cli_anything/samgeo/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as python -m cli_anything.samgeo."""
+
+from cli_anything.samgeo.samgeo_cli import cli
+
+if __name__ == "__main__":
+    cli()

segment_geospatial-1.3.3/agent-harness/cli_anything/samgeo/core/__init__.py

@@ -0,0 +1 @@
+"""Core modules for cli-anything-samgeo."""

segment_geospatial-1.3.3/agent-harness/cli_anything/samgeo/core/data.py

@@ -0,0 +1,229 @@
+"""Data operations: download tiles, inspect rasters, reproject, split."""
+
+import os
+
+from cli_anything.samgeo.utils.samgeo_backend import (
+    get_common_module,
+    get_rasterio,
+)
+
+
+def raster_info(path):
+    """Get information about a raster file.
+
+    Args:
+        path: Path to the raster file.
+
+    Returns:
+        dict: Raster metadata.
+    """
+    rasterio = get_rasterio()
+    path = os.path.abspath(path)
+
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Raster file not found: {path}")
+
+    with rasterio.open(path) as src:
+        info = {
+            "path": path,
+            "driver": src.driver,
+            "crs": str(src.crs) if src.crs else None,
+            "width": src.width,
+            "height": src.height,
+            "bands": src.count,
+            "dtype": str(src.dtypes[0]) if src.dtypes else None,
+            "bounds": {
+                "left": src.bounds.left,
+                "bottom": src.bounds.bottom,
+                "right": src.bounds.right,
+                "top": src.bounds.top,
+            },
+            "transform": list(src.transform)[:6],
+            "nodata": src.nodata,
+            "file_size": os.path.getsize(path),
+        }
+
+    return info
+
+
+def download_tiles(
+    output,
+    bbox,
+    zoom=None,
+    resolution=None,
+    source="OpenStreetMap",
+    crs="EPSG:3857",
+    to_cog=False,
+    **kwargs,
+):
+    """Download TMS tiles as a GeoTIFF.
+
+    Args:
+        output: Output file path.
+        bbox: Bounding box as [west, south, east, north].
+        zoom: Zoom level. If None, auto-detected from resolution.
+        resolution: Resolution in meters. Alternative to zoom.
+        source: Tile source name or URL.
+        crs: Output CRS.
+        to_cog: Whether to convert to Cloud-Optimized GeoTIFF.
+        **kwargs: Additional kwargs.
+
+    Returns:
+        dict: Result with output path and file size.
+    """
+    common = get_common_module()
+    output = os.path.abspath(output)
+    parent = os.path.dirname(output)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+    common.tms_to_geotiff(
+        output=output,
+        bbox=bbox,
+        zoom=zoom,
+        resolution=resolution,
+        source=source,
+        crs=crs,
+        to_cog=to_cog,
+        **kwargs,
+    )
+
+    result = {
+        "output": output,
+        "file_size": os.path.getsize(output) if os.path.exists(output) else 0,
+        "bbox": bbox,
+        "zoom": zoom,
+        "source": source,
+        "crs": crs,
+    }
+
+    return result
+
+
+def reproject_raster(
+    input_path, output_path, dst_crs="EPSG:4326", resampling="nearest", to_cog=True
+):
+    """Reproject a raster file to a new CRS.
+
+    Args:
+        input_path: Input raster path.
+        output_path: Output raster path.
+        dst_crs: Target CRS.
+        resampling: Resampling method.
+        to_cog: Whether to output as COG.
+
+    Returns:
+        dict: Result with output path and new CRS.
+    """
+    common = get_common_module()
+    input_path = os.path.abspath(input_path)
+    output_path = os.path.abspath(output_path)
+
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Input raster not found: {input_path}")
+
+    parent = os.path.dirname(output_path)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+    common.reproject(
+        image=input_path,
+        output=output_path,
+        dst_crs=dst_crs,
+        resampling=resampling,
+        to_cog=to_cog,
+    )
+
+    result = {
+        "input": input_path,
+        "output": output_path,
+        "dst_crs": dst_crs,
+        "file_size": os.path.getsize(output_path) if os.path.exists(output_path) else 0,
+    }
+
+    return result
+
+
+def split_raster_tiles(input_path, out_dir, tile_size=256, overlap=0):
+    """Split a raster into tiles.
+
+    Args:
+        input_path: Input raster path.
+        out_dir: Output directory for tiles.
+        tile_size: Tile size in pixels (int or [width, height]).
+        overlap: Overlap in pixels.
+
+    Returns:
+        dict: Result with tile count and output directory.
+    """
+    common = get_common_module()
+    input_path = os.path.abspath(input_path)
+    out_dir = os.path.abspath(out_dir)
+
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Input raster not found: {input_path}")
+
+    os.makedirs(out_dir, exist_ok=True)
+
+    common.split_raster(
+        filename=input_path,
+        out_dir=out_dir,
+        tile_size=tile_size,
+        overlap=overlap,
+    )
+
+    tiles = [f for f in os.listdir(out_dir) if f.endswith((".tif", ".tiff"))]
+
+    result = {
+        "input": input_path,
+        "output_dir": out_dir,
+        "tile_count": len(tiles),
+        "tile_size": tile_size,
+        "overlap": overlap,
+    }
+
+    return result
+
+
+def image_to_cog(source, output=None, profile="deflate"):
+    """Convert a raster to Cloud-Optimized GeoTIFF.
+
+    Args:
+        source: Input raster path.
+        output: Output path. If None, writes to a new *_cog.tif file
+            alongside the source.
+        profile: COG profile.
+
+    Returns:
+        dict: Result with output path.
+    """
+    common = get_common_module()
+    source = os.path.abspath(source)
+
+    if not os.path.exists(source):
+        raise FileNotFoundError(f"Source raster not found: {source}")
+
+    common.image_to_cog(source=source, dst_path=output, profile=profile)
+
+    out = output or source
+    result = {
+        "output": os.path.abspath(out),
+        "file_size": os.path.getsize(out) if os.path.exists(out) else 0,
+        "profile": profile,
+    }
+
+    return result
+
+
+def list_basemaps(free_only=True):
+    """List available TMS basemap sources.
+
+    Args:
+        free_only: Only list free tile services.
+
+    Returns:
+        list: List of basemap names.
+    """
+    common = get_common_module()
+    basemaps = common.get_basemaps(free_only=free_only)
+    return sorted(basemaps.keys()) if isinstance(basemaps, dict) else sorted(basemaps)