segment-geospatial 1.2.0__tar.gz → 1.2.2__tar.gz

{segment_geospatial-1.2.0 → segment_geospatial-1.2.2}/.pre-commit-config.yaml

@@ -12,7 +12,7 @@ repos:
             args: ["--maxkb=500"]
 
     - repo: https://github.com/astral-sh/ruff-pre-commit
-      rev: v0.14.9
+      rev: v0.14.14
       hooks:
           - id: ruff
             types_or: [pyi, jupyter]
@@ -29,6 +29,6 @@ repos:
                 ]
 
     - repo: https://github.com/kynan/nbstripout
-      rev: 0.8.2
+      rev: 0.9.0
       hooks:
           - id: nbstripout

{segment_geospatial-1.2.0 → segment_geospatial-1.2.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: segment-geospatial
-Version: 1.2.0
-Summary: Meta AI' Segment Anything Model (SAM) for Geospatial Data.
+Version: 1.2.2
+Summary: Meta AI's Segment Anything Model (SAM) for Geospatial Data.
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT license
 Project-URL: Homepage, https://github.com/opengeos/segment-geospatial
@@ -146,6 +146,31 @@ SamGeo is also available as a [QGIS plugin](https://github.com/opengeos/qgis-sam
 
 ## Installation
 
+### Install with pixi (Recommended)
+
+For the most reliable installation experience, especially on Windows or when dealing with complex dependencies like PyTorch/CUDA and SAM 3, we recommend using [pixi](https://pixi.prefix.dev/latest). Pixi provides faster and more reliable dependency resolution than conda/mamba and avoids common numpy version conflicts. See the [full pixi installation guide](https://samgeo.gishub.org/installation/#install-with-pixi-recommended) for detailed instructions.
+
+Quick start with pixi:
+
+```bash
+# Install pixi (Linux/macOS)
+curl -fsSL https://pixi.sh/install.sh | sh
+
+# Or on Windows (PowerShell)
+powershell -ExecutionPolicy Bypass -c "irm -useb https://pixi.sh/install.ps1 | iex"
+
+# Create a new pixi project
+pixi init geo
+cd geo
+
+# Edit pixi.toml with your configuration (see docs for GPU/CPU examples)
+# Then install
+pixi install
+
+# Start Jupyter Lab
+pixi run jupyter lab
+```
+
 ### Install from PyPI
 
 **segment-geospatial** is available on [PyPI](https://pypi.org/project/segment-geospatial/) and can be installed in several ways so that its dependencies can be controlled more granularly. This reduces package size for CI environments, since not every time all of the models will be used.
@@ -191,7 +216,7 @@ If your system has a GPU, but the above commands do not install the GPU version
 conda install -c conda-forge segment-geospatial "pytorch=*=cuda*"
 ```
 
-Samgeo-geospatial has some optional dependencies that are not included in the default conda environment. To install these dependencies, run the following command:
+segment-geospatial has some optional dependencies that are not included in the default conda environment. To install these dependencies, run the following command:
 
 ```bash
 conda install -c conda-forge groundingdino-py segment-anything-fast

{segment_geospatial-1.2.0 → segment_geospatial-1.2.2}/README.md

@@ -47,6 +47,31 @@ SamGeo is also available as a [QGIS plugin](https://github.com/opengeos/qgis-sam
 
 ## Installation
 
+### Install with pixi (Recommended)
+
+For the most reliable installation experience, especially on Windows or when dealing with complex dependencies like PyTorch/CUDA and SAM 3, we recommend using [pixi](https://pixi.prefix.dev/latest). Pixi provides faster and more reliable dependency resolution than conda/mamba and avoids common numpy version conflicts. See the [full pixi installation guide](https://samgeo.gishub.org/installation/#install-with-pixi-recommended) for detailed instructions.
+
+Quick start with pixi:
+
+```bash
+# Install pixi (Linux/macOS)
+curl -fsSL https://pixi.sh/install.sh | sh
+
+# Or on Windows (PowerShell)
+powershell -ExecutionPolicy Bypass -c "irm -useb https://pixi.sh/install.ps1 | iex"
+
+# Create a new pixi project
+pixi init geo
+cd geo
+
+# Edit pixi.toml with your configuration (see docs for GPU/CPU examples)
+# Then install
+pixi install
+
+# Start Jupyter Lab
+pixi run jupyter lab
+```
+
 ### Install from PyPI
 
 **segment-geospatial** is available on [PyPI](https://pypi.org/project/segment-geospatial/) and can be installed in several ways so that its dependencies can be controlled more granularly. This reduces package size for CI environments, since not every time all of the models will be used.
@@ -92,7 +117,7 @@ If your system has a GPU, but the above commands do not install the GPU version
 conda install -c conda-forge segment-geospatial "pytorch=*=cuda*"
 ```
 
-Samgeo-geospatial has some optional dependencies that are not included in the default conda environment. To install these dependencies, run the following command:
+segment-geospatial has some optional dependencies that are not included in the default conda environment. To install these dependencies, run the following command:
 
 ```bash
 conda install -c conda-forge groundingdino-py segment-anything-fast

segment_geospatial-1.2.2/docs/faq.md

@@ -0,0 +1,48 @@
+# Frequently Asked Questions (FAQ)
+
+## Coordinate Reference Systems (CRS)
+
+### Does samgeo automatically convert my imagery to EPSG:4326?
+
+**No.** samgeo does **NOT** automatically reproject or convert your GeoTIFF files to EPSG:4326. Your imagery stays in its native coordinate system throughout the entire segmentation process.
+
+**Key points:**
+- When you load a GeoTIFF with `set_image()` or use `generate_masks_tiled()`, the image data is read directly without any CRS transformation
+- The output masks inherit the same CRS as your input imagery
+- The `reproject()` function in `samgeo.common` has EPSG:4326 as a default parameter, but it's **only used when you explicitly call that function** - it is NOT called automatically during segmentation
+
+**Why might you see distortion?**
+1. Your visualization tool is displaying the results in EPSG:4326 (like some web map libraries)
+2. You're manually calling the `reproject()` function somewhere in your workflow
+3. Your original imagery already has CRS-related issues
+
+**Recommendation:**
+- Verify your input TIF has the correct CRS metadata using `gdalinfo` or rasterio (`src.crs`)
+- The output masks will preserve the same CRS as your input
+- If you need to reproject for visualization, do it as a separate step AFTER segmentation:
+  ```python
+  from samgeo import common
+  common.reproject("input_masks.tif", "output_epsg4326.tif", dst_crs="EPSG:4326")
+  ```
+
+### How can I check the CRS of my GeoTIFF?
+
+Using GDAL:
+```bash
+gdalinfo your_file.tif
+```
+
+Using Python with rasterio:
+```python
+import rasterio
+with rasterio.open("your_file.tif") as src:
+    print(f"CRS: {src.crs}")
+```
+
+### My imagery looks distorted during segmentation
+
+The segmentation algorithm works on pixel values, not geographic coordinates, so CRS should not affect segmentation quality. If you're seeing distortion:
+
+1. **Check if it's a visualization issue:** The distortion might only appear when viewing results in a different CRS
+2. **Verify your input data:** Use `gdalinfo` to check if the CRS metadata is correct
+3. **Try reprojecting to a more suitable CRS:** Some projections preserve shape better than others for specific regions (e.g., UTM for local areas)

segment_geospatial-1.2.2/docs/installation.md

@@ -0,0 +1,277 @@
+# Installation
+
+## Install with pixi (Recommended)
+
+Installing **segment-geospatial** with `uv` or `pip` can be challenging on some platforms (especially Windows) due to complicated pytorch/cuda dependencies and numpy version conflicts. [Pixi](https://pixi.prefix.dev/latest) is recommended to avoid these issues, as it provides faster and more reliable dependency resolution than conda or mamba.
+
+### 1) Install Pixi
+
+#### Linux/macOS (bash/zsh)
+
+```bash
+curl -fsSL https://pixi.sh/install.sh | sh
+```
+
+Close and re-open your terminal (or reload your shell) so `pixi` is on your `PATH`. Then confirm:
+
+```bash
+pixi --version
+```
+
+#### Windows (PowerShell)
+
+Open **PowerShell** (preferably as a normal user, Admin not required), then run:
+
+```powershell
+powershell -ExecutionPolicy Bypass -c "irm -useb https://pixi.sh/install.ps1 | iex"
+```
+
+Close and re-open PowerShell, then confirm:
+
+```powershell
+pixi --version
+```
+
+---
+
+### 2) Create a Pixi project
+
+Navigate to a directory where you want to create the project and run:
+
+```bash
+pixi init geo
+cd geo
+```
+
+---
+
+### 3) Configure `pixi.toml`
+
+Open `pixi.toml` in the `geo` directory and replace its contents with the following depending on your system.
+
+If you have an NVIDIA GPU with CUDA, run `nvidia-smi` to check the CUDA version.
+
+#### For GPU with CUDA 12.x:
+
+```toml
+[workspace]
+channels = ["https://prefix.dev/conda-forge"]
+name = "geo"
+platforms = ["linux-64", "win-64"]
+
+[system-requirements]
+cuda = "12.0"
+
+[dependencies]
+python = "3.12.*"
+pytorch-gpu = ">=2.7.1,<3"
+segment-geospatial = ">=1.2.0"
+sam3 = ">=0.1.0.20251211"
+jupyterlab = "*"
+ipykernel = "*"
+libopenblas = ">=0.3.30"
+```
+
+#### For GPU with CUDA 13.x:
+
+```toml
+[workspace]
+channels = ["https://prefix.dev/conda-forge"]
+name = "geo"
+platforms = ["linux-64", "win-64"]
+
+[system-requirements]
+cuda = "13.0"
+
+[dependencies]
+python = "3.12.*"
+pytorch-gpu = ">=2.7.1,<3"
+segment-geospatial = ">=1.2.0"
+sam3 = ">=0.1.0.20251211"
+jupyterlab = "*"
+ipykernel = "*"
+```
+
+#### For CPU:
+
+```toml
+[workspace]
+channels = ["https://prefix.dev/conda-forge"]
+name = "geo"
+platforms = ["linux-64", "win-64"]
+
+[dependencies]
+python = "3.12.*"
+pytorch-cpu = ">=2.7.1,<3"
+segment-geospatial = ">=1.2.0"
+sam3 = ">=0.1.0.20251211"
+jupyterlab = "*"
+ipykernel = "*"
+libopenblas = ">=0.3.30"
+```
+
+---
+
+### 4) Install the environment
+
+From the `geo` folder:
+
+```bash
+pixi install
+```
+
+This step may take several minutes on first install depending on your internet connection and system.
+
+---
+
+### 5) Verify PyTorch + CUDA
+
+If you have an NVIDIA GPU with CUDA, run the following command to verify the PyTorch + CUDA installation:
+
+```bash
+pixi run python -c "import torch; print('PyTorch:', torch.__version__); print('CUDA available:', torch.cuda.is_available()); print('GPU:', (torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'None'))"
+```
+
+Expected output should be like this:
+
+-   `PyTorch: 2.7.1` (or higher)
+-   `CUDA available: True`
+-   `GPU: NVIDIA RTX 4090` (your GPU name)
+
+If CUDA is `False`, check:
+
+-   `nvidia-smi` works in your terminal
+-   NVIDIA driver is up to date
+
+---
+
+### 6) Request access to SAM 3 (Optional)
+
+To use SAM 3, you will need to request access by filling out this form on Hugging Face at <https://huggingface.co/facebook/sam3>. Once your request has been approved, run the following command in the terminal to authenticate:
+
+```bash
+pixi run hf auth login
+```
+
+After authentication, you can download the SAM 3 model from Hugging Face:
+
+```bash
+pixi run hf download facebook/sam3
+```
+
+**Important Note**: SAM 3 currently requires an NVIDIA GPU with CUDA support. You won't be able to use SAM 3 if you have a CPU only system ([source](https://github.com/facebookresearch/sam3/issues/164)). You will get an error message like this: `Failed to load model: Torch not compiled with CUDA enabled`.
+
+---
+
+### 7) Start Jupyter Lab
+
+To start using segment-geospatial in Jupyter Lab:
+
+```bash
+pixi run jupyter lab
+```
+
+This will open Jupyter Lab in your default browser. You can now create a new notebook and start using segment-geospatial!
+
+---
+
+## Install from PyPI
+
+**segment-geospatial** is available on [PyPI](https://pypi.org/project/segment-geospatial/). To install **segment-geospatial**, run this command in your terminal:
+
+```bash
+pip install segment-geospatial
+```
+
+## Install from conda-forge
+
+**segment-geospatial** is also available on [conda-forge](https://anaconda.org/conda-forge/segment-geospatial). If you have
+[Anaconda](https://www.anaconda.com/distribution/#download-section) or [Miniconda](https://docs.conda.io/en/latest/miniconda.html) installed on your computer, you can install segment-geospatial using the following commands. It is recommended to create a fresh conda environment for **segment-geospatial**. The following commands will create a new conda environment named `geo` and install **segment-geospatial** and its dependencies:
+
+```bash
+conda create -n geo python
+conda activate geo
+conda install -c conda-forge mamba
+mamba install -c conda-forge segment-geospatial
+```
+
+If your system has a GPU, but the above commands do not install the GPU version of pytorch, you can force the installation of the GPU version of pytorch using the following command:
+
+```bash
+mamba install -c conda-forge segment-geospatial "pytorch=*=cuda*"
+```
+
+Samgeo-geospatial has some optional dependencies that are not included in the default conda environment. To install these dependencies, run the following command:
+
+```bash
+mamba install -c conda-forge groundingdino-py segment-anything-fast
+```
+
+## Install from GitHub
+
+To install the development version from GitHub using [Git](https://git-scm.com/), run the following command in your terminal:
+
+```bash
+pip install git+https://github.com/opengeos/segment-geospatial
+```
+
+## Use docker
+
+You can also use [docker](https://hub.docker.com/r/giswqs/segment-geospatial/) to run segment-geospatial:
+
+```bash
+docker run -it -p 8888:8888 giswqs/segment-geospatial:latest
+```
+
+To enable GPU for segment-geospatial, run the following command to run a short benchmark on your GPU:
+
+```bash
+docker run --rm -it --gpus=all nvcr.io/nvidia/k8s/cuda-sample:nbody nbody -gpu -benchmark
+```
+
+The output should be similar to the following:
+
+```text
+Run "nbody -benchmark [-numbodies=<numBodies>]" to measure performance.
+        -fullscreen       (run n-body simulation in fullscreen mode)
+        -fp64             (use double precision floating point values for simulation)
+        -hostmem          (stores simulation data in host memory)
+        -benchmark        (run benchmark to measure performance)
+        -numbodies=<N>    (number of bodies (>= 1) to run in simulation)
+        -device=<d>       (where d=0,1,2.... for the CUDA device to use)
+        -numdevices=<i>   (where i=(number of CUDA devices > 0) to use for simulation)
+        -compare          (compares simulation results running once on the default GPU and once on the CPU)
+        -cpu              (run n-body simulation on the CPU)
+        -tipsy=<file.bin> (load a tipsy model file for simulation)
+
+NOTE: The CUDA Samples are not meant for performance measurements. Results may vary when GPU Boost is enabled.
+
+> Windowed mode
+> Simulation data stored in video memory
+> Single precision floating point simulation
+> 1 Devices used for simulation
+GPU Device 0: "Turing" with compute capability 7.5
+
+> Compute 7.5 CUDA device: [Quadro RTX 5000]
+49152 bodies, total time for 10 iterations: 69.386 ms
+= 348.185 billion interactions per second
+= 6963.703 single-precision GFLOP/s at 20 flops per interaction
+```
+
+If you encounter the following error:
+
+```text
+nvidia-container-cli: initialization error: load library failed: libnvidia-ml.so.1: cannot open shared object file: no such file or directory: unknown.
+```
+
+Try adding `sudo` to the command:
+
+```bash
+sudo docker run --rm -it --gpus=all nvcr.io/nvidia/k8s/cuda-sample:nbody nbody -gpu -benchmark
+```
+
+Once everything is working, you can run the following command to start a Jupyter Notebook server:
+
+```bash
+docker run -it -p 8888:8888 --gpus=all giswqs/segment-geospatial:latest
+```

{segment_geospatial-1.2.0 → segment_geospatial-1.2.2}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "segment-geospatial"
-version = "1.2.0"
+version = "1.2.2"
 dynamic = [
     "dependencies",
 ]
-description = "Meta AI' Segment Anything Model (SAM) for Geospatial Data."
+description = "Meta AI's Segment Anything Model (SAM) for Geospatial Data."
 readme = "README.md"
 requires-python = ">=3.10"
 license = {text = "MIT license"}
@@ -111,7 +111,7 @@ dependencies = {file = ["requirements.txt"]}
 universal = true
 
 [tool.bumpversion]
-current_version = "1.2.0"
+current_version = "1.2.2"
 commit = true
 tag = true
 

{segment_geospatial-1.2.0 → segment_geospatial-1.2.2}/samgeo/__init__.py

@@ -2,7 +2,7 @@
 
 __author__ = """Qiusheng Wu"""
 __email__ = "giswqs@gmail.com"
-__version__ = "1.2.0"
+__version__ = "1.2.2"
 
 
 from .samgeo import *  # noqa: F403

{segment_geospatial-1.2.0 → segment_geospatial-1.2.2}/samgeo/common.py

@@ -328,6 +328,7 @@ def reproject(
 
     """
     import rasterio as rio
+    import shutil
     from rasterio.warp import Resampling, calculate_default_transform, reproject
 
     if isinstance(resampling, str):
@@ -339,6 +340,15 @@ def reproject(
     if not os.path.exists(os.path.dirname(output)):
         os.makedirs(os.path.dirname(output))
 
+    # Check if input and output are the same file (in-place reprojection)
+    in_place = os.path.normpath(image) == os.path.normpath(output)
+
+    # If in-place, use a temporary file to avoid file locking issues on Windows
+    if in_place:
+        temp_output = temp_file_path(".tif")
+    else:
+        temp_output = output
+
     with rio.open(image, **kwargs) as src:
         transform, width, height = calculate_default_transform(
             src.crs, dst_crs, src.width, src.height, *src.bounds
@@ -353,7 +363,7 @@ def reproject(
             }
         )
 
-        with rio.open(output, "w", **kwargs) as dst:
+        with rio.open(temp_output, "w", **kwargs) as dst:
             for i in range(1, src.count + 1):
                 reproject(
                     source=rio.band(src, i),
@@ -366,6 +376,10 @@ def reproject(
                     **kwargs,
                 )
 
+    # If in-place, replace the original file with the temporary file
+    if in_place:
+        shutil.move(temp_output, output)
+
     if to_cog:
         image_to_cog(output, output)
 
@@ -1818,7 +1832,7 @@ def update_package(out_dir=None, keep=False, **kwargs):
             shutil.rmtree(pkg_dir)
             try:
                 os.remove(filename)
-            except:
+            except Exception:
                 pass
 
         print("Package updated successfully.")
@@ -1872,7 +1886,7 @@ def sam_map_gui(
     # Skip the image layer if localtileserver is not available
     try:
         m.add_raster(sam.source, layer_name="Image")
-    except:
+    except Exception:
         pass
 
     m.fg_markers = []
@@ -2265,7 +2279,7 @@ def sam_map_gui(
                         ):
                             try:
                                 os.remove(sam.prediction_fp)
-                            except:
+                            except Exception:
                                 pass
                         # Skip the image layer if localtileserver is not available
                         try:
@@ -2291,7 +2305,7 @@ def sam_map_gui(
                                     zoom_to_layer=False,
                                 )
 
-                        except:
+                        except Exception:
                             pass
                         output.clear_output()
                         segment_button.value = False
@@ -2386,9 +2400,9 @@ def sam_map_gui(
                     bg_count.value = 0
                 try:
                     os.remove(sam.prediction_fp)
-                except:
+                except Exception:
                     pass
-            except:
+            except Exception:
                 pass
 
     reset_button.observe(reset_button_click, "value")
@@ -2605,7 +2619,7 @@ def text_sam_gui(
     # Skip the image layer if localtileserver is not available
     try:
         m.add_raster(sam.source, layer_name="Image")
-    except:
+    except Exception:
         pass
 
     widget_width = "280px"
@@ -2953,7 +2967,7 @@ def text_sam_gui(
                 if hasattr(m, "layer_name") and m.find_layer(m.layer_name) is not None:
                     m.remove_layer(m.find_layer(m.layer_name))
                 m.clear_drawings()
-            except:
+            except Exception:
                 pass
 
     reset_button.observe(reset_button_click, "value")
@@ -3520,9 +3534,22 @@ def images_to_video(
         height, width, _ = frame.shape
         video_size = (width, height)
 
-    # TODO: This video codec is giving me some problems, not sure if it's the correct one
-    fourcc = cv2.VideoWriter_fourcc(*"avc1")  # Define the codec for mp4
-    video_writer = cv2.VideoWriter(output_video, fourcc, fps, video_size)
+    # Try different codecs for compatibility across platforms
+    codecs = ["avc1", "mp4v", "XVID"]
+    video_writer = None
+
+    for codec in codecs:
+        fourcc = cv2.VideoWriter_fourcc(*codec)
+        video_writer = cv2.VideoWriter(output_video, fourcc, fps, video_size)
+        if video_writer.isOpened():
+            break
+        video_writer.release()
+
+    if not video_writer or not video_writer.isOpened():
+        raise RuntimeError(
+            f"Failed to initialize video writer for {output_video}. "
+            "Please ensure you have the necessary codecs installed."
+        )
 
     for image_path in images:
         frame = cv2.imread(image_path)
@@ -3536,6 +3563,21 @@ def images_to_video(
         video_writer.write(frame)
 
     video_writer.release()
+
+    # Verify the video file was created
+    if not os.path.exists(output_video):
+        raise RuntimeError(
+            f"Failed to create video file {output_video}. "
+            "The video writer completed but the file was not saved to disk."
+        )
+
+    # Verify the file has content
+    if os.path.getsize(output_video) == 0:
+        raise RuntimeError(
+            f"Video file {output_video} was created but is empty. "
+            "This may indicate a codec problem."
+        )
+
     print(f"Video saved as {output_video}")
 
 

{segment_geospatial-1.2.0 → segment_geospatial-1.2.2}/samgeo/fer.py

@@ -996,7 +996,7 @@ def regularize(
 
             try:
                 RecSim, rering = RecSimilar(dpolygon)
-            except:
+            except Exception:
                 continue
             if RecSim == 1:
                 oupolygon.AddGeometry(rering)
@@ -1014,7 +1014,7 @@ def regularize(
 
             try:
                 vx = VListDiret(vList)
-            except:
+            except Exception:
                 continue
             svList = Smooth(vList, vx, 25, averageLength)