GIS Classification

Python project for land cover classification using GIS data (GeoTIFF + Shapefile).

Project Structure

gis-classification/
├── main.py              # Main script with parameters
├── requirements.txt     # Dependencies
├── data/                # Input data folder
├── output/              # Classification results
├── static/              # Web frontend
└── src/
    ├── classifier.py    # Main classification pipeline
    ├── api.py           # FastAPI web server
    ├── data/
    │   └── loader.py    # Data loading (GeoTIFF, Shapefile)
    ├── strategies/
    │   ├── base.py          # Strategy interface
    │   └── classifiers.py   # Built-in strategies (RF, SVM, LR)
    └── utils/

Installation

pip install -r requirements.txt

Or with uv:

uv pip install -r requirements.txt

Usage

CLI Mode

Place your input files in data/:
- landsat.tif - GeoTIFF from Landsat
- polygons.shp - Shapefile with class labels
Configure parameters in main.py:
- Input/output paths
- Classification strategy (RandomForest, SVM, LogisticRegression)
- Training parameters
Run:

python main.py

Web Interface

Start the web server:

uvicorn src.api:app --host 0.0.0.0 --port 8000 --reload

Then open http://localhost:8000 in your browser.

Features:

Upload GeoTIFF raster and Shapefile training data
Select classification strategy (Random Forest, SVM, Logistic Regression, MLE)
View training metrics (Accuracy, Cohen's Kappa)
Interactive map visualization with Leaflet
Download classified GeoTIFF results

API Endpoints:

GET / - Web interface
POST /train - Train classifier with uploaded files
POST /predict - Run classification
GET /result/{session_id} - Get result metadata
GET /result/{session_id}/download - Download classified GeoTIFF
GET /docs - Interactive API documentation (Swagger UI)

Adding Custom Classification Strategy

Create a new class implementing ClassificationStrategy:

from src.strategies import ClassificationStrategy
import numpy as np

class MyCustomStrategy(ClassificationStrategy):
    def train(self, X: np.ndarray, y: np.ndarray) -> None:
        # Your training logic
        pass

    def predict(self, X: np.ndarray) -> np.ndarray:
        # Your prediction logic
        pass

    def predict_proba(self, X: np.ndarray) -> np.ndarray:
        pass

    def get_params(self) -> dict:
        pass

    @property
    def name(self) -> str:
        return "MyCustom"

Then use in main.py:

STRATEGY = MyCustomStrategy()

Output

output/classified.tif - Classified raster (GeoTIFF)
Console output with accuracy metrics (Accuracy, Cohen's Kappa)
Web interface visualization with interactive map

Metrics

The classifier reports:

Accuracy: Overall classification accuracy
Cohen's Kappa: Agreement statistic accounting for chance (values > 0.8 indicate excellent agreement)

3 KiB Raw Blame History