Integrate S2 Pipeline vegetation_indices.py

- Use same index calculation functions from main pipeline
- Support all 13 indices: NDVI, EVI, NDWI, NDRE, RECI, SMI, NDSI, PRI, PSRI, MCARI, SASI, SOMI, SFI
- Fetch all 13 bands from Sentinel-2 and calculate indices locally
- Add water-specific colormap for NDWI/SMI

app.py

@@ -1,11 +1,13 @@
 """
 AGROW Heatmap Service
 =====================
-Generates heatmap images from Sentinel-2 satellite data.
+Generates heatmap images from Sentinel-2 satellite data using the same
+vegetation indices from the main Sentinel-2 pipeline.
 """
 
 import os
 import io
+import re
 import base64
 import logging
 from datetime import datetime, timedelta
@@ -27,6 +29,9 @@ from sentinelhub import (
     MimeType, bbox_to_dimensions, SentinelHubCatalog
 )
 
+# Import vegetation indices from S2 pipeline
+from vegetation_indices import INDEX_FUNCTIONS, calculate_all_indices
+
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -35,7 +40,7 @@ logger = logging.getLogger(__name__)
 app = FastAPI(
     title="AGROW Heatmap Service",
     description="Generate heatmap images from Sentinel-2 vegetation indices",
-    version="1.0.0"
+    version="2.0.0"
 )
 
 # CORS
@@ -47,6 +52,7 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+
 # Sentinel Hub configuration
 def get_sh_config():
     config = SHConfig()
@@ -62,7 +68,7 @@ class HeatmapRequest(BaseModel):
     center_lat: float
     center_lon: float
     field_size_hectares: float = 10.0
-    index_type: str = "NDVI"  # NDVI, EVI, NDWI, SMI, NDRE
+    index_type: str = "NDVI"  # Any index from vegetation_indices.py
 
 
 class HeatmapResponse(BaseModel):
@@ -73,6 +79,7 @@ class HeatmapResponse(BaseModel):
     mean_value: float
     image_base64: str
     timestamp: str
+    image_date: Optional[str] = None
 
 
 # Custom colormap for vegetation indices
@@ -88,78 +95,54 @@ def get_vegetation_colormap():
     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];
+def get_water_colormap():
+    """Colormap for water-related indices (NDWI, SMI)."""
+    colors = [
+        (0.9, 0.6, 0.3),   # Brown (dry)
+        (0.95, 0.9, 0.5),  # Yellow
+        (0.5, 0.8, 0.9),   # Light blue
+        (0.2, 0.5, 0.8),   # Blue
+        (0.1, 0.3, 0.6),   # Dark blue (wet)
+    ]
+    return LinearSegmentedColormap.from_list('water', colors, N=256)
+
+
+# Evalscript to fetch all 13 bands
+FULL_BANDS_EVALSCRIPT = """
+//VERSION=3
+function setup() {
+    return {
+        input: [{
+            bands: ["B01", "B02", "B03", "B04", "B05", "B06", "B07", "B08", "B8A", "B09", "B11", "B12", "dataMask"],
+            units: "REFLECTANCE"
+        }],
+        output: {
+            bands: 13,
+            sampleType: "FLOAT32"
         }
-        """,
-    }
-    
-    return evalscripts.get(index_type, evalscripts["NDVI"])
+    };
+}
+
+function evaluatePixel(sample) {
+    return [
+        sample.B01, sample.B02, sample.B03, sample.B04,
+        sample.B05, sample.B06, sample.B07, sample.B08,
+        sample.B8A, sample.B09, sample.B11, sample.B12,
+        sample.dataMask
+    ];
+}
+"""
+
+
+def parse_timestamp(ts_str: str) -> datetime:
+    """Parse ISO timestamp with variable fractional seconds."""
+    ts_str = ts_str.replace('Z', '+00:00')
+    match = re.match(r'(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})\.(\d+)([+-]\d{2}:\d{2})', ts_str)
+    if match:
+        base, frac, tz = match.groups()
+        frac = frac.ljust(6, '0')[:6]
+        ts_str = f"{base}.{frac}{tz}"
+    return datetime.fromisoformat(ts_str)
 
 
 def generate_heatmap_image(data: np.ndarray, index_type: str) -> tuple:
@@ -181,8 +164,12 @@ def generate_heatmap_image(data: np.ndarray, index_type: str) -> tuple:
     # Create figure
     fig, ax = plt.subplots(figsize=(8, 8), dpi=100)
     
-    # Apply colormap
-    cmap = get_vegetation_colormap()
+    # Select colormap based on index type
+    if index_type in ['NDWI', 'SMI']:
+        cmap = get_water_colormap()
+    else:
+        cmap = get_vegetation_colormap()
+    
     im = ax.imshow(data_normalized, cmap=cmap, interpolation='bilinear')
     
     # Add colorbar
@@ -215,10 +202,12 @@ def generate_heatmap_image(data: np.ndarray, index_type: str) -> tuple:
 async def root():
     return {
         "service": "AGROW Heatmap Service",
-        "version": "1.0.0",
+        "version": "2.0.0",
         "status": "running",
+        "supported_indices": list(INDEX_FUNCTIONS.keys()),
         "endpoints": {
             "/generate-heatmap": "POST - Generate heatmap from coordinates",
+            "/generate-heatmap-image": "GET - Get heatmap as PNG directly",
             "/health": "GET - Health check"
         }
     }
@@ -226,20 +215,26 @@ async def root():
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy"}
+    return {"status": "healthy", "indices_available": list(INDEX_FUNCTIONS.keys())}
 
 
 @app.post("/generate-heatmap", response_model=HeatmapResponse)
 async def generate_heatmap(request: HeatmapRequest):
     """Generate a heatmap image for the specified location and index type."""
     
+    # Validate index type
+    if request.index_type not in INDEX_FUNCTIONS:
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Invalid index type '{request.index_type}'. Supported: {list(INDEX_FUNCTIONS.keys())}"
+        )
+    
     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)))
@@ -256,26 +251,21 @@ async def generate_heatmap(request: HeatmapRequest):
         
         # 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
+        # Create request for all 13 bands
         sh_request = SentinelHubRequest(
-            evalscript=evalscript,
+            evalscript=FULL_BANDS_EVALSCRIPT,
             input_data=[
                 SentinelHubRequest.input_data(
                     data_collection=SENTINEL2_L2A_CDSE,
@@ -295,12 +285,19 @@ async def generate_heatmap(request: HeatmapRequest):
         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()
+        logger.info(f"Fetched data shape: {data.shape}")
+        
+        # Calculate the requested index using the S2 pipeline function
+        # Need to remove dataMask (last band) for index calculation
+        img_data = data[:, :, :12]  # Remove dataMask
+        
+        index_func = INDEX_FUNCTIONS[request.index_type]
+        index_data = index_func(img_data)
+        
+        logger.info(f"Calculated {request.index_type}: min={np.nanmin(index_data):.4f}, max={np.nanmax(index_data):.4f}")
         
         # Generate heatmap
-        img_base64, min_val, max_val, mean_val = generate_heatmap_image(data, request.index_type)
+        img_base64, min_val, max_val, mean_val = generate_heatmap_image(index_data, request.index_type)
         
         return HeatmapResponse(
             success=True,
@@ -309,7 +306,8 @@ async def generate_heatmap(request: HeatmapRequest):
             max_value=max_val,
             mean_value=mean_val,
             image_base64=img_base64,
-            timestamp=datetime.now().isoformat()
+            timestamp=datetime.now().isoformat(),
+            image_date=end_date.strftime('%Y-%m-%d')
         )
         
     except HTTPException:

vegetation_indices.py

@@ -0,0 +1,246 @@
+"""
+Vegetation Indices Calculator
+==============================
+
+This module provides functions to calculate 10 vegetation indices from Sentinel-2 data
+and perform temporal analysis.
+
+Indices:
+- NDVI: Normalized Difference Vegetation Index
+- EVI: Enhanced Vegetation Index
+- NDWI: Normalized Difference Water Index
+- NDRE: Normalized Difference Red Edge
+- RECI: Red Edge Chlorophyll Index
+- SMI: Soil Moisture Index
+- NDSI: Normalized Difference Snow Index
+- PRI: Photochemical Reflectance Index
+- PSRI: Plant Senescence Reflectance Index
+- MCARI: Modified Chlorophyll Absorption Ratio Index
+- SASI: Salinity Index
+- SOMI: Soil Organic Matter Index
+- SFI: Soil Fertility Index
+"""
+
+import numpy as np
+from typing import Dict, List, Tuple
+import datetime
+from datetime import timedelta
+
+# ==================== INDEX CALCULATION FUNCTIONS ====================
+
+def calculate_ndvi(img: np.ndarray) -> np.ndarray:
+    """NDVI = (NIR - RED) / (NIR + RED)"""
+    nir = img[:, :, 7]  # B08
+    red = img[:, :, 3]  # B04
+    return (nir - red) / (nir + red + 1e-10)
+
+def calculate_evi(img: np.ndarray) -> np.ndarray:
+    """EVI = 2.5 * ((NIR - RED) / (NIR + 6*RED - 7.5*BLUE + 1))"""
+    nir = img[:, :, 7]  # B08
+    red = img[:, :, 3]  # B04
+    blue = img[:, :, 1]  # B02
+    return 2.5 * ((nir - red) / (nir + 6*red - 7.5*blue + 1))
+
+def calculate_ndwi(img: np.ndarray) -> np.ndarray:
+    """NDWI = (GREEN - NIR) / (GREEN + NIR)"""
+    green = img[:, :, 2]  # B03
+    nir = img[:, :, 7]  # B08
+    return (green - nir) / (green + nir + 1e-10)
+
+def calculate_ndre(img: np.ndarray) -> np.ndarray:
+    """NDRE = (NIR - RedEdge) / (NIR + RedEdge)"""
+    nir = img[:, :, 7]  # B08
+    red_edge = img[:, :, 4]  # B05
+    return (nir - red_edge) / (nir + red_edge + 1e-10)
+
+def calculate_reci(img: np.ndarray) -> np.ndarray:
+    """RECI = (NIR / RedEdge) - 1"""
+    nir = img[:, :, 7]  # B08
+    red_edge = img[:, :, 4]  # B05
+    return (nir / (red_edge + 1e-10)) - 1
+
+def calculate_smi(img: np.ndarray) -> np.ndarray:
+    """SMI = (SWIR1 - SWIR2) / (SWIR1 + SWIR2)"""
+    swir1 = img[:, :, 10]  # B11
+    swir2 = img[:, :, 11]  # B12
+    return (swir1 - swir2) / (swir1 + swir2 + 1e-10)
+
+def calculate_ndsi(img: np.ndarray) -> np.ndarray:
+    """NDSI = (GREEN - SWIR1) / (GREEN + SWIR1)"""
+    green = img[:, :, 2]  # B03
+    swir1 = img[:, :, 10]  # B11
+    return (green - swir1) / (green + swir1 + 1e-10)
+
+def calculate_pri(img: np.ndarray) -> np.ndarray:
+    """PRI = (B02 - B03) / (B02 + B03)"""
+    b02 = img[:, :, 1]  # B02
+    b03 = img[:, :, 2]  # B03
+    return (b02 - b03) / (b02 + b03 + 1e-10)
+
+def calculate_psri(img: np.ndarray) -> np.ndarray:
+    """PSRI = (RED - GREEN) / NIR"""
+    red = img[:, :, 3]  # B04
+    green = img[:, :, 2]  # B03
+    nir = img[:, :, 7]  # B08
+    return (red - green) / (nir + 1e-10)
+
+def calculate_mcari(img: np.ndarray) -> np.ndarray:
+    """MCARI = ((B05 - B04) - 0.2 * (B05 - B03)) * (B05 / B04)"""
+    b03 = img[:, :, 2]  # B03
+    b04 = img[:, :, 3]  # B04
+    b05 = img[:, :, 4]  # B05
+    return ((b05 - b04) - 0.2 * (b05 - b03)) * (b05 / (b04 + 1e-10))
+
+def calculate_sasi(img: np.ndarray) -> np.ndarray:
+    """SASI (Salinity Index) = SQRT(B11 * B04)"""
+    swir1 = img[:, :, 10]  # B11
+    red = img[:, :, 3]  # B04
+    return np.sqrt(swir1 * red)
+
+def calculate_somi(img: np.ndarray) -> np.ndarray:
+    """SOMI (Soil Organic Matter Index) = (B08 + B04) / (B11 + B12)"""
+    nir = img[:, :, 7]  # B08
+    red = img[:, :, 3]  # B04
+    swir1 = img[:, :, 10]  # B11
+    swir2 = img[:, :, 11]  # B12
+    return (nir + red) / (swir1 + swir2 + 1e-10)
+
+def calculate_sfi(img: np.ndarray) -> np.ndarray:
+    """SFI (Soil Fertility Index) = (NDVI * SOMI) / SASI
+    Combines vegetation health, organic matter, and salinity"""
+    ndvi = calculate_ndvi(img)
+    somi = calculate_somi(img)
+    sasi = calculate_sasi(img)
+    return (ndvi * somi) / (sasi + 1e-10)
+
+# Index registry
+INDEX_FUNCTIONS = {
+    'NDVI': calculate_ndvi,
+    'EVI': calculate_evi,
+    'NDWI': calculate_ndwi,
+    'NDRE': calculate_ndre,
+    'RECI': calculate_reci,
+    'SMI': calculate_smi,
+    'NDSI': calculate_ndsi,
+    'PRI': calculate_pri,
+    'PSRI': calculate_psri,
+    'MCARI': calculate_mcari,
+    'SASI': calculate_sasi,
+    'SOMI': calculate_somi,
+    'SFI': calculate_sfi
+}
+
+# ==================== BATCH CALCULATION ====================
+
+def calculate_all_indices(img: np.ndarray) -> Dict[str, np.ndarray]:
+    """
+    Calculate all 10 vegetation indices for a single image.
+    
+    Args:
+        img: Image array of shape (height, width, 12) with reflectance values
+        
+    Returns:
+        Dictionary mapping index names to 2D arrays
+    """
+    indices = {}
+    for name, func in INDEX_FUNCTIONS.items():
+        indices[name] = func(img)
+    return indices
+
+def calculate_indices_temporal(images: np.ndarray) -> Dict[str, np.ndarray]:
+    """
+    Calculate all indices for multiple time steps.
+    
+    Args:
+        images: Array of shape (time, height, width, 12)
+        
+    Returns:
+        Dictionary mapping index names to 3D arrays (time, height, width)
+    """
+    indices_data = {}
+    
+    for index_name, calc_func in INDEX_FUNCTIONS.items():
+        index_series = []
+        for img in images:
+            index_map = calc_func(img)
+            index_series.append(index_map)
+        indices_data[index_name] = np.array(index_series)
+    
+    return indices_data
+
+# ==================== STATISTICS ====================
+
+def get_field_statistics(index_map: np.ndarray) -> Dict[str, float]:
+    """
+    Calculate statistics for a single index map.
+    
+    Returns:
+        Dictionary with mean, std, min, max, median
+    """
+    return {
+        'mean': float(np.nanmean(index_map)),
+        'std': float(np.nanstd(index_map)),
+        'min': float(np.nanmin(index_map)),
+        'max': float(np.nanmax(index_map)),
+        'median': float(np.nanmedian(index_map)),
+        'valid_pixels': int(np.sum(~np.isnan(index_map)))
+    }
+
+def get_temporal_statistics(indices_temporal: Dict[str, np.ndarray]) -> Dict[str, Dict]:
+    """
+    Calculate temporal statistics for all indices.
+    
+    Args:
+        indices_temporal: Dictionary with index names and 3D arrays (time, height, width)
+        
+    Returns:
+        Dictionary with temporal stats for each index
+    """
+    temporal_stats = {}
+    
+    for index_name, data in indices_temporal.items():
+        stats = {
+            'mean_over_time': np.nanmean(data, axis=0),
+            'std_over_time': np.nanstd(data, axis=0),
+            'max_over_time': np.nanmax(data, axis=0),
+            'min_over_time': np.nanmin(data, axis=0),
+            'range': np.nanmax(data, axis=0) - np.nanmin(data, axis=0),
+            'temporal_trend': data[-1] - data[0] if len(data) >= 2 else np.zeros_like(data[0]),
+        }
+        
+        # Rolling average (window size = 3)
+        if len(data) >= 3:
+            rolling_avg = np.array([np.nanmean(data[max(0, i-2):i+1], axis=0) 
+                                   for i in range(len(data))])
+            stats['rolling_avg_3'] = rolling_avg
+        
+        temporal_stats[index_name] = stats
+    
+    return temporal_stats
+
+def get_summary_report(indices_temporal: Dict[str, np.ndarray], 
+                       dates: List[str]) -> Dict:
+    """
+    Generate a comprehensive summary report.
+    
+    Returns:
+        Dictionary with summary statistics and temporal trends
+    """
+    report = {
+        'dates': dates,
+        'num_images': len(dates),
+        'indices': {}
+    }
+    
+    for index_name, data in indices_temporal.items():
+        index_report = {
+            'latest': get_field_statistics(data[-1]),
+            'oldest': get_field_statistics(data[0]),
+            'mean_values_over_time': [float(np.nanmean(data[i])) for i in range(len(dates))],
+            'change': float(np.nanmean(data[-1]) - np.nanmean(data[0])),
+            'max_in_field': float(np.nanmax(data)),
+            'min_in_field': float(np.nanmin(data))
+        }
+        report['indices'][index_name] = index_report
+    
+    return report