DEV Community

Cover image for Can AI Actually Prove Land Changed? I Built GeoShift to Find Out
Sukriti Chatterjee
Sukriti Chatterjee

Posted on

Can AI Actually Prove Land Changed? I Built GeoShift to Find Out

Two satellite photos of the same landscape, taken six months apart. One looks slightly darker, the other has long afternoon shadows, and the seasonal vegetation has shifted from vibrant spring green to dry late-summer amber.

If you look closely at a specific corner of the image, a patch of forest seems to have disappeared.

How do you programmatically prove that land actually changed—and that your computer isn't just reacting to lighting variations, sun angle, or a cloudier afternoon?

To answer this question from a forensic engineering perspective, I built GeoShift: an open-source, MVP change-detection pipeline designed to isolate genuine environmental transformations—like deforestation, water body shrinkage, and urban expansion—from temporal noise.

Here is the real engineering pipeline behind it, why naive computer vision methods fail, and how spectral index differencing actually works under the hood.

The Illusion: Why Naive Pixel Comparison Fails

The most intuitive way to compare two images in computer vision is standard image subtraction:

           Δ = |Image_After - Image_Before|
Enter fullscreen mode Exit fullscreen mode

If you take two standard RGB satellite passes and run a naive pixel-diff matrix via OpenCV or NumPy, the output is almost completely unusable. The entire image lights up with false positives.

[Raw RGB Before]  --- (Naive Matrix Subtraction) --->  [Pure Noise Matrix]
[Raw RGB After ]                                       🚨 False Positives (Shadows, Seasons, Sun Angle)
Enter fullscreen mode Exit fullscreen mode

Why does standard pixel comparison break down?

  1. Atmospheric & Solar Variance: Satellites do not capture scenes under studio lighting. Changes in solar zenith angle, atmospheric scattering, and seasonal weather drastically alter raw digital numbers (DN) and surface reflectance values.
  2. Sub-Pixel Spatial Misalignment: Unless two rasters share the exact same Coordinate Reference System (CRS), grid resolution, and georeferencing alignment, subtracting pixels directly means comparing physical terrain that is offset by several meters.

Before running any mathematical comparison, raw satellite bands must pass through a strict spatial reprojection pipeline using Rasterio to ensure identical coordinate alignment and matching bounding extents.

The Forensic Solution: Spectral Index Differencing

To reliably detect land transformation across seasons without being fooled by ambient lighting, we move away from raw RGB channels and analyze specific multispectral bands.

Healthy green vegetation absorbs red light (for photosynthesis) while strongly reflecting Near-Infrared (NIR) light due to its internal leaf cell structure. GeoShift computes the Normalized Difference Vegetation Index (NDVI) for each timestamp:

NDVI = (NIR - Red)/(NIR + Red)

Because NDVI uses a normalized ratio between $[-1.0, 1.0]$, it naturally cancels out uniform atmospheric interference and illumination differences that distort raw RGB pixels.

Timestamp T0 (Before)  ➔  Compute NDVI_T0  ┐
                                           ├➔  Δ_NDVI = (NDVI_T1 - NDVI_T0)  ➔  Threshold Binary Mask
Timestamp T1 (After)   ➔  Compute NDVI_T1  ┘
Enter fullscreen mode Exit fullscreen mode

Isolating True Change: The Delta Matrix

GeoShift calculates the temporal difference raster:

        Δ_NDVI = NDVI_After - NDVI_Before
Enter fullscreen mode Exit fullscreen mode
  • Δ_NDVI << 0 (Sharp Negative Drop):** Represents sudden canopy loss, clear-cutting, or deforestation.
  • Δ_NDVI ~ 0 (Near Zero):** Unchanged terrain or standard seasonal variance.
  • Δ_NDVI >> 0 (Sharp Positive Gain):** Reforestation or new crop growth cycles. 
import numpy as np

def compute_ndvi(nir_band: np.ndarray, red_band: np.ndarray) -> np.ndarray:
    """Calculates Normalized Difference Vegetation Index with zero-division safety."""
    denominator = nir_band + red_band
    # Prevent division by zero on masked or nodata pixels
    ndvi = np.where(denominator > 0, (nir_band - red_band) / denominator, 0)
    return ndvi

def compute_change_mask(ndvi_before: np.ndarray, ndvi_after: np.ndarray, threshold: float = -0.25) -> np.ndarray:
    """Generates a binary change mask for significant vegetation loss."""
    delta_ndvi = ndvi_after - ndvi_before
    # Values dropping past the negative threshold indicate true vegetation loss
    change_mask = delta_ndvi < threshold
    return change_mask.astype(np.uint8)
Enter fullscreen mode Exit fullscreen mode

The Engineering Trade-off: Thresholding

Converting a continuous Δ_NDVI matrix into a binary change mask requires selecting a threshold cut-off.

  • Setting the threshold too conservatively (e.g., Δ < -0.10$) captures seasonal dry periods as false deforestation.
  • Setting it too aggressively (e.g., Δ < -0.45$) misses partial tree felling or road carving.

In this MVP stage, threshold tuning is deliberately exposed to the user to balance sensitivity based on regional terrain characteristics.

System Architecture & Processing Pipeline

GeoShift couples a lightweight Python processing engine with an interactive Streamlit visualization workspace.

GeoShift-Change-Detection/
├── data/                 # Raw GeoTIFF input rasters & exported change masks
├── src/
│   ├── preprocessor.py   # Raster reprojection, CRS alignment & band extraction
│   ├── differencer.py    # Multi-temporal NDVI/NDWI computation & masking
│   ├── generate_mock_data.py # Synthetic multi-band raster generator
│   └── test_differencer.py   # Automated unit validation
├── results/              # Rendered difference heatmaps & area metrics
└── app.py                # Streamlit dashboard interface
Enter fullscreen mode Exit fullscreen mode

Technology Breakdown

  • Rasterio & NumPy: Reads geospatial metadata, extracts NIR/Red raster arrays, and performs vector-accelerated matrix differencing.
  • OpenCV & Matplotlib: Generates high-contrast thermal change heatmaps, binary anomaly contours, and side-by-side composite overlays.
  • Streamlit: Serves the frontend interface, computing real-time metrics such as total percentage of land changed and providing one-click exports for georeferenced GeoTIFF masks.

What GeoShift Can and Cannot Prove (Yet)

Honesty in geospatial engineering separates functional systems from marketing demos.

What it proves today:

  • Significant Land Alteration: Clearly isolates large-scale clear-cutting, major infrastructure development, and severe water reservoir shrinkage.
  • Spectral Normalization: Successfully ignores minor sun glare and ambient exposure changes that break standard computer vision models.

Current Limitations:

  • Manual Threshold Calibration: The sensitivity cut-off is configured manually per scene rather than dynamically learned via machine learning models.
  • Batch Ingestion: The current baseline runs on local user-uploaded GeoTIFFs or generated synthetic scenes, rather than pulling direct, automated ingestion feeds from Sentinel-2 or Landsat STAC APIs.

Try the Project & Follow the Build

The complete codebase, documentation, and synthetic data generators for GeoShift are open-source on GitHub:

How do you handle threshold tuning and atmospheric correction in your geospatial pipelines? Drop your thoughts, favorite remote sensing libraries, or architecture questions below!

Top comments (0)