Add AGROW Heatmap Service - Generate vegetation index heatmaps from Sentinel-2 data

Features:
- POST /generate-heatmap - Returns base64 image + stats
- GET /generate-heatmap-image - Returns PNG directly
- Supports NDVI, EVI, NDWI, NDRE, SMI indices
- Custom vegetation colormap (red-yellow-green)

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    libgdal-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY app.py .
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,74 @@
 ---
-title: Heatmap
-emoji: 🐠
-colorFrom: pink
-colorTo: red
+title: AGROW Heatmap Service
+emoji: 🗺️
+colorFrom: green
+colorTo: yellow
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AGROW Heatmap Service
+
+This service generates heatmap images from Sentinel-2 satellite data for agricultural field visualization.
+
+## Features
+
+- Generate vegetation index heatmaps (NDVI, EVI, NDWI, NDRE, SMI)
+- Custom colormap optimized for agricultural analysis
+- Returns images as base64 or direct PNG
+
+## API Endpoints
+
+### POST `/generate-heatmap`
+
+Generate a heatmap for the specified location and index type.
+
+**Request:**
+```json
+{
+  "center_lat": 26.1885,
+  "center_lon": 91.6894,
+  "field_size_hectares": 10.0,
+  "index_type": "NDVI"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "index_type": "NDVI",
+  "min_value": 0.2,
+  "max_value": 0.85,
+  "mean_value": 0.65,
+  "image_base64": "...",
+  "timestamp": "2025-12-05T10:30:00"
+}
+```
+
+### GET `/generate-heatmap-image`
+
+Get heatmap as PNG image directly.
+
+**Query Parameters:**
+- `center_lat`: Field center latitude
+- `center_lon`: Field center longitude
+- `field_size_hectares`: Field size (default: 10.0)
+- `index_type`: Index type (default: "NDVI")
+
+## Supported Indices
+
+| Index | Description |
+|-------|-------------|
+| NDVI  | Normalized Difference Vegetation Index - General crop health |
+| EVI   | Enhanced Vegetation Index - Dense vegetation monitoring |
+| NDWI  | Normalized Difference Water Index - Water/moisture content |
+| NDRE  | Normalized Difference Red Edge Index - Chlorophyll content |
+| SMI   | Soil Moisture Index - Soil water content |
+
+## Environment Variables
+
+Required secrets in HF Space:
+- `SH_CLIENT_ID`: Sentinel Hub client ID
+- `SH_CLIENT_SECRET`: Sentinel Hub client secret

app.py

@@ -0,0 +1,348 @@
+"""
+AGROW Heatmap Service
+=====================
+Generates heatmap images from Sentinel-2 satellite data.
+"""
+
+import os
+import io
+import base64
+import logging
+from datetime import datetime, timedelta
+from typing import Optional
+
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')  # Non-interactive backend
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+from PIL import Image
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import Response
+from pydantic import BaseModel
+
+from sentinelhub import (
+    SHConfig, BBox, CRS, DataCollection, SentinelHubRequest,
+    MimeType, bbox_to_dimensions, SentinelHubCatalog
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI
+app = FastAPI(
+    title="AGROW Heatmap Service",
+    description="Generate heatmap images from Sentinel-2 vegetation indices",
+    version="1.0.0"
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Sentinel Hub configuration
+def get_sh_config():
+    config = SHConfig()
+    config.sh_client_id = os.environ.get('SH_CLIENT_ID', '')
+    config.sh_client_secret = os.environ.get('SH_CLIENT_SECRET', '')
+    config.sh_base_url = 'https://sh.dataspace.copernicus.eu'
+    config.sh_token_url = 'https://identity.dataspace.copernicus.eu/auth/realms/CDSE/protocol/openid-connect/token'
+    return config
+
+
+# Request models
+class HeatmapRequest(BaseModel):
+    center_lat: float
+    center_lon: float
+    field_size_hectares: float = 10.0
+    index_type: str = "NDVI"  # NDVI, EVI, NDWI, SMI, NDRE
+
+
+class HeatmapResponse(BaseModel):
+    success: bool
+    index_type: str
+    min_value: float
+    max_value: float
+    mean_value: float
+    image_base64: str
+    timestamp: str
+
+
+# Custom colormap for vegetation indices
+def get_vegetation_colormap():
+    """Create a colormap from red (low) to yellow (mid) to green (high)."""
+    colors = [
+        (0.8, 0.2, 0.2),   # Red (stress/low)
+        (0.9, 0.6, 0.2),   # Orange
+        (0.95, 0.9, 0.3),  # Yellow (moderate)
+        (0.6, 0.8, 0.3),   # Light green
+        (0.2, 0.6, 0.2),   # Dark green (healthy/high)
+    ]
+    return LinearSegmentedColormap.from_list('vegetation', colors, N=256)
+
+
+def create_evalscript(index_type: str) -> str:
+    """Create Sentinel Hub evalscript for the requested index."""
+    
+    evalscripts = {
+        "NDVI": """
+        //VERSION=3
+        function setup() {
+            return {
+                input: ["B04", "B08", "dataMask"],
+                output: { bands: 1, sampleType: "FLOAT32" }
+            };
+        }
+        function evaluatePixel(sample) {
+            let ndvi = (sample.B08 - sample.B04) / (sample.B08 + sample.B04);
+            return [ndvi * sample.dataMask];
+        }
+        """,
+        "EVI": """
+        //VERSION=3
+        function setup() {
+            return {
+                input: ["B02", "B04", "B08", "dataMask"],
+                output: { bands: 1, sampleType: "FLOAT32" }
+            };
+        }
+        function evaluatePixel(sample) {
+            let evi = 2.5 * (sample.B08 - sample.B04) / (sample.B08 + 6 * sample.B04 - 7.5 * sample.B02 + 1);
+            return [evi * sample.dataMask];
+        }
+        """,
+        "NDWI": """
+        //VERSION=3
+        function setup() {
+            return {
+                input: ["B03", "B08", "dataMask"],
+                output: { bands: 1, sampleType: "FLOAT32" }
+            };
+        }
+        function evaluatePixel(sample) {
+            let ndwi = (sample.B03 - sample.B08) / (sample.B03 + sample.B08);
+            return [ndwi * sample.dataMask];
+        }
+        """,
+        "NDRE": """
+        //VERSION=3
+        function setup() {
+            return {
+                input: ["B05", "B08", "dataMask"],
+                output: { bands: 1, sampleType: "FLOAT32" }
+            };
+        }
+        function evaluatePixel(sample) {
+            let ndre = (sample.B08 - sample.B05) / (sample.B08 + sample.B05);
+            return [ndre * sample.dataMask];
+        }
+        """,
+        "SMI": """
+        //VERSION=3
+        function setup() {
+            return {
+                input: ["B8A", "B11", "dataMask"],
+                output: { bands: 1, sampleType: "FLOAT32" }
+            };
+        }
+        function evaluatePixel(sample) {
+            let smi = (sample.B8A - sample.B11) / (sample.B8A + sample.B11);
+            return [smi * sample.dataMask];
+        }
+        """,
+    }
+    
+    return evalscripts.get(index_type, evalscripts["NDVI"])
+
+
+def generate_heatmap_image(data: np.ndarray, index_type: str) -> tuple:
+    """Generate a heatmap image from index data."""
+    
+    # Handle NaN values
+    valid_mask = ~np.isnan(data)
+    if not np.any(valid_mask):
+        raise ValueError("No valid data pixels found")
+    
+    min_val = float(np.nanmin(data))
+    max_val = float(np.nanmax(data))
+    mean_val = float(np.nanmean(data))
+    
+    # Normalize data to 0-1 range for colormap
+    data_normalized = np.clip((data - min_val) / (max_val - min_val + 1e-8), 0, 1)
+    data_normalized = np.nan_to_num(data_normalized, nan=0.5)
+    
+    # Create figure
+    fig, ax = plt.subplots(figsize=(8, 8), dpi=100)
+    
+    # Apply colormap
+    cmap = get_vegetation_colormap()
+    im = ax.imshow(data_normalized, cmap=cmap, interpolation='bilinear')
+    
+    # Add colorbar
+    cbar = plt.colorbar(im, ax=ax, shrink=0.8, pad=0.02)
+    cbar.set_label(f'{index_type} Value', fontsize=10)
+    
+    # Format colorbar ticks to show actual values
+    cbar_ticks = np.linspace(0, 1, 5)
+    cbar_labels = [f'{min_val + t * (max_val - min_val):.2f}' for t in cbar_ticks]
+    cbar.set_ticks(cbar_ticks)
+    cbar.set_ticklabels(cbar_labels)
+    
+    # Style
+    ax.set_title(f'{index_type} Heatmap', fontsize=14, fontweight='bold')
+    ax.axis('off')
+    
+    # Save to buffer
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', bbox_inches='tight', facecolor='white', edgecolor='none')
+    plt.close(fig)
+    buf.seek(0)
+    
+    # Convert to base64
+    img_base64 = base64.b64encode(buf.getvalue()).decode('utf-8')
+    
+    return img_base64, min_val, max_val, mean_val
+
+
+@app.get("/")
+async def root():
+    return {
+        "service": "AGROW Heatmap Service",
+        "version": "1.0.0",
+        "status": "running",
+        "endpoints": {
+            "/generate-heatmap": "POST - Generate heatmap from coordinates",
+            "/health": "GET - Health check"
+        }
+    }
+
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy"}
+
+
+@app.post("/generate-heatmap", response_model=HeatmapResponse)
+async def generate_heatmap(request: HeatmapRequest):
+    """Generate a heatmap image for the specified location and index type."""
+    
+    try:
+        logger.info(f"Generating {request.index_type} heatmap for ({request.center_lat}, {request.center_lon})")
+        
+        config = get_sh_config()
+        
+        # Calculate bounding box from center and field size
+        # Approximate conversion: 1 degree ≈ 111km at equator
+        field_radius_km = np.sqrt(request.field_size_hectares / 100) / 2
+        lat_offset = field_radius_km / 111
+        lon_offset = field_radius_km / (111 * np.cos(np.radians(request.center_lat)))
+        
+        bbox = BBox(
+            (
+                request.center_lon - lon_offset,
+                request.center_lat - lat_offset,
+                request.center_lon + lon_offset,
+                request.center_lat + lat_offset
+            ),
+            crs=CRS.WGS84
+        )
+        
+        # Calculate resolution (10m per pixel)
+        size = bbox_to_dimensions(bbox, resolution=10)
+        
+        # Ensure minimum size
+        size = (max(size[0], 64), max(size[1], 64))
+        
+        # Get recent date
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=30)
+        
+        # Create evalscript
+        evalscript = create_evalscript(request.index_type)
+        
+        # Define data collection for CDSE
+        SENTINEL2_L2A_CDSE = DataCollection.define_from(
+            DataCollection.SENTINEL2_L2A,
+            service_url='https://sh.dataspace.copernicus.eu'
+        )
+        
+        # Create request
+        sh_request = SentinelHubRequest(
+            evalscript=evalscript,
+            input_data=[
+                SentinelHubRequest.input_data(
+                    data_collection=SENTINEL2_L2A_CDSE,
+                    time_interval=(start_date.strftime('%Y-%m-%d'), end_date.strftime('%Y-%m-%d')),
+                    mosaicking_order='leastCC'
+                )
+            ],
+            responses=[SentinelHubRequest.output_response('default', MimeType.TIFF)],
+            bbox=bbox,
+            size=size,
+            config=config
+        )
+        
+        # Fetch data
+        data = sh_request.get_data()[0]
+        
+        if data is None or data.size == 0:
+            raise HTTPException(status_code=404, detail="No satellite data available for this location")
+        
+        # Squeeze if needed
+        if len(data.shape) > 2:
+            data = data.squeeze()
+        
+        # Generate heatmap
+        img_base64, min_val, max_val, mean_val = generate_heatmap_image(data, request.index_type)
+        
+        return HeatmapResponse(
+            success=True,
+            index_type=request.index_type,
+            min_value=min_val,
+            max_value=max_val,
+            mean_value=mean_val,
+            image_base64=img_base64,
+            timestamp=datetime.now().isoformat()
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error generating heatmap: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/generate-heatmap-image")
+async def generate_heatmap_image_direct(
+    center_lat: float,
+    center_lon: float,
+    field_size_hectares: float = 10.0,
+    index_type: str = "NDVI"
+):
+    """Generate and return heatmap as PNG image directly."""
+    
+    request = HeatmapRequest(
+        center_lat=center_lat,
+        center_lon=center_lon,
+        field_size_hectares=field_size_hectares,
+        index_type=index_type
+    )
+    
+    response = await generate_heatmap(request)
+    
+    # Decode base64 to bytes
+    img_bytes = base64.b64decode(response.image_base64)
+    
+    return Response(content=img_bytes, media_type="image/png")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.2
+numpy>=1.24.0
+matplotlib>=3.7.0
+Pillow>=9.0.0
+sentinelhub>=3.9.0
+python-dotenv>=1.0.0