v3.0.0: Multi-mode Heatmap Service

PIXEL-WISE MODE (fast):
- soil_moisture (SMI)
- soil_organic_matter (SOMI)
- soil_fertility (SFI)
- soil_salinity (SASI)
- greenness (NDVI)
- nitrogen_level (NDRE)
- photosynthetic_capacity (PRI)

LLM MODE (CNN+Clustering+LLM):
- pest_risk
- disease_risk
- nutrient_stress
- stress_zones

Features:
- Auto-detect mode from metric type
- CNN stress detection with patch_size=4, stride=2
- K-Means clustering for stress patterns
- Gemini LLM analysis with full context
- Added GNDVI index for nutrient stress

Dockerfile

@@ -12,9 +12,12 @@ RUN apt-get update && apt-get install -y \
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy application files
+# Copy all application files
 COPY app.py .
 COPY vegetation_indices.py .
+COPY stress_detection_model.py .
+COPY stress_detection_preprocessing.py .
+COPY llm_analysis.py .
 
 # Expose port
 EXPOSE 7860

app.py

@@ -1,10 +1,13 @@
 """
 AGROW Heatmap Service
 =====================
-Generates heatmap images from Sentinel-2 satellite data using pixel-wise
-vegetation indices with patch-based statistics.
+Multi-mode heatmap generation with pixel-wise indices AND CNN+Clustering+LLM analysis.
 
-Version: 2.3.0 - Pixel-wise + 100-200 patch analysis
+Version: 3.0.0 - Integrated Stress Detection
+
+Modes (auto-detected from metric):
+- Pixel-wise: SMI, SOMI, SFI, SASI, NDVI, NDRE, PRI, GNDVI
+- CNN+LLM: pest_risk, disease_risk, nutrient_stress, stress_zones
 """
 
 import os
@@ -13,7 +16,7 @@ import base64
 import logging
 import traceback
 from datetime import datetime, timedelta
-from typing import Optional, List
+from typing import Optional, List, Dict, Any
 
 import numpy as np
 from scipy.ndimage import gaussian_filter
@@ -32,10 +35,14 @@ from sentinelhub import (
     MimeType, bbox_to_dimensions
 )
 
-from vegetation_indices import INDEX_FUNCTIONS
+# Import modules
+from vegetation_indices import INDEX_FUNCTIONS, calculate_all_indices
+from stress_detection_model import StressDetectionModel, get_stress_category, prepare_llm_context
+from stress_detection_preprocessing import preprocess_for_model
+from llm_analysis import configure_gemini, prepare_indices_context, format_stress_context
 
 # ============================================================================
-# LOGGING CONFIGURATION
+# LOGGING
 # ============================================================================
 logging.basicConfig(
     level=logging.INFO,
@@ -58,19 +65,44 @@ def log_detail(key: str, value):
 # ============================================================================
 # STARTUP
 # ============================================================================
-log_section("AGROW HEATMAP SERVICE v2.3.0")
-log_detail("Mode", "Pixel-wise indices + 100-200 patch analysis")
-log_detail("Indices available", list(INDEX_FUNCTIONS.keys()))
-log_detail("SH_CLIENT_ID", "✓ Set" if os.environ.get('SH_CLIENT_ID') else "✗ NOT SET")
-log_detail("SH_CLIENT_SECRET", "✓ Set" if os.environ.get('SH_CLIENT_SECRET') else "✗ NOT SET")
+log_section("AGROW HEATMAP SERVICE v3.0.0")
+log_detail("Mode", "Pixel-wise + CNN+Clustering+LLM")
+log_detail("Pixel-wise indices", "SMI, SOMI, SFI, SASI, NDVI, NDRE, PRI, GNDVI")
+log_detail("LLM metrics", "pest_risk, disease_risk, nutrient_stress, stress_zones")
+log_detail("SH_CLIENT_ID", "✓" if os.environ.get('SH_CLIENT_ID') else "✗")
+log_detail("GEMINI_API_KEY", "✓" if os.environ.get('GEMINI_API_KEY') else "✗")
 
 # ============================================================================
-# FASTAPI SETUP
+# METRIC CONFIGURATION
+# ============================================================================
+# Metrics that use simple pixel-wise index calculation
+PIXELWISE_METRICS = {
+    'soil_moisture': 'SMI',
+    'soil_organic_matter': 'SOMI',
+    'soil_fertility': 'SFI',
+    'soil_salinity': 'SASI',
+    'greenness': 'NDVI',
+    'nitrogen_level': 'NDRE',
+    'photosynthetic_capacity': 'PRI',
+}
+
+# Metrics that require CNN+Clustering+LLM
+LLM_METRICS = {
+    'pest_risk': {'primary_index': 'NDVI', 'use_stress': True},
+    'disease_risk': {'primary_index': 'PSRI', 'use_stress': True},
+    'nutrient_stress': {'primary_index': 'GNDVI', 'use_stress': True},
+    'stress_zones': {'primary_index': 'NDVI', 'use_stress': True},
+}
+
+ALL_METRICS = list(PIXELWISE_METRICS.keys()) + list(LLM_METRICS.keys())
+
+# ============================================================================
+# FASTAPI
 # ============================================================================
 app = FastAPI(
     title="AGROW Heatmap Service",
-    description="Pixel-wise vegetation indices with 100-200 patch analysis",
-    version="2.3.0"
+    description="Multi-mode heatmap with pixel-wise and CNN+LLM analysis",
+    version="3.0.0"
 )
 
 app.add_middleware(
@@ -99,27 +131,32 @@ class HeatmapRequest(BaseModel):
     center_lat: float
     center_lon: float
     field_size_hectares: float
-    index_type: str = "NDVI"
+    metric: str  # e.g., "soil_moisture", "pest_risk"
     gaussian_sigma: float = 1.5
     show_field_boundary: bool = True
-    target_patches: int = 150  # Target 100-200 patches
 
 
 class HeatmapResponse(BaseModel):
     success: bool
-    index_type: str
+    metric: str
+    mode: str  # "pixelwise" or "llm"
+    index_used: str
     min_value: float
     max_value: float
     mean_value: float
-    std_value: float
     image_base64: str
     timestamp: str
     image_date: Optional[str] = None
     image_size: Optional[str] = None
-    num_patches: int
-    patch_grid: Optional[str] = None
-    patches: Optional[List[dict]] = None
+    # Patch analysis (for pixel-wise)
+    num_patches: Optional[int] = None
     health_summary: Optional[dict] = None
+    # LLM analysis (for risk metrics)
+    level: Optional[str] = None
+    analysis: Optional[str] = None
+    stress_score: Optional[float] = None
+    cluster_distribution: Optional[dict] = None
+    recommendations: Optional[List[str]] = None
 
 # ============================================================================
 # COLORMAPS
@@ -132,22 +169,9 @@ def get_water_colormap():
     colors = [(0.9, 0.6, 0.3), (0.95, 0.9, 0.5), (0.5, 0.8, 0.9), (0.2, 0.5, 0.8), (0.1, 0.3, 0.6)]
     return LinearSegmentedColormap.from_list('water', colors, N=256)
 
-# ============================================================================
-# HEALTH CATEGORIZATION
-# ============================================================================
-def get_health_category(value: float, index_type: str) -> str:
-    if index_type in ['NDVI', 'EVI', 'NDRE']:
-        if value >= 0.6: return 'Healthy'
-        elif value >= 0.3: return 'Moderate'
-        else: return 'Stressed'
-    elif index_type in ['NDWI', 'SMI']:
-        if value >= 0.2: return 'Adequate'
-        elif value >= 0.0: return 'Moderate'
-        else: return 'Dry'
-    else:
-        if value >= 0.5: return 'Healthy'
-        elif value >= 0.25: return 'Moderate'
-        else: return 'Stressed'
+def get_stress_colormap():
+    colors = [(0.2, 0.7, 0.2), (0.8, 0.8, 0.2), (0.9, 0.5, 0.1), (0.8, 0.2, 0.2)]
+    return LinearSegmentedColormap.from_list('stress', colors, N=256)
 
 # ============================================================================
 # EVALSCRIPT
@@ -170,129 +194,98 @@ function evaluatePixel(sample) {
 """
 
 # ============================================================================
-# PATCH ANALYSIS (100-200 patches)
+# PIXEL-WISE ANALYSIS
 # ============================================================================
-def analyze_patches(data: np.ndarray, index_type: str, target_patches: int = 150) -> tuple:
-    """
-    Divide field into ~100-200 patches for statistical analysis.
-    Uses pixel-wise index values, then aggregates by patch.
-    """
+def get_health_category(value: float, index_type: str) -> str:
+    if index_type in ['NDVI', 'EVI', 'NDRE', 'GNDVI']:
+        if value >= 0.6: return 'Healthy'
+        elif value >= 0.3: return 'Moderate'
+        else: return 'Stressed'
+    elif index_type in ['NDWI', 'SMI']:
+        if value >= 0.2: return 'Adequate'
+        elif value >= 0.0: return 'Moderate'
+        else: return 'Dry'
+    else:
+        if value >= 0.5: return 'Healthy'
+        elif value >= 0.25: return 'Moderate'
+        else: return 'Stressed'
+
+
+def analyze_patches_pixelwise(data: np.ndarray, index_type: str, target_patches: int = 150) -> tuple:
+    """Divide field into ~100-200 patches for statistical analysis."""
     h, w = data.shape
-    
-    # Calculate grid size to get ~target_patches
-    # patches = rows * cols, so we want sqrt(target_patches) for each dimension
-    grid_size = int(np.sqrt(target_patches))
-    grid_size = max(10, min(15, grid_size))  # Keep between 10x10 and 15x15
-    
-    patch_h = max(1, h // grid_size)
-    patch_w = max(1, w // grid_size)
-    
+    grid_size = max(10, min(15, int(np.sqrt(target_patches))))
+    patch_h, patch_w = max(1, h // grid_size), max(1, w // grid_size)
     actual_rows = h // patch_h if patch_h > 0 else 1
     actual_cols = w // patch_w if patch_w > 0 else 1
     
-    logger.info(f"    • Grid: {actual_rows} rows × {actual_cols} cols = {actual_rows * actual_cols} patches")
-    logger.info(f"    • Patch size: {patch_h}×{patch_w} pixels")
-    
     patches_list = []
     health_counts = {}
     
     for row in range(actual_rows):
         for col in range(actual_cols):
-            y_start = row * patch_h
-            y_end = min((row + 1) * patch_h, h)
-            x_start = col * patch_w
-            x_end = min((col + 1) * patch_w, w)
-            
+            y_start, y_end = row * patch_h, min((row + 1) * patch_h, h)
+            x_start, x_end = col * patch_w, min((col + 1) * patch_w, w)
             patch = data[y_start:y_end, x_start:x_end]
             valid_pixels = np.sum(~np.isnan(patch))
             
             if valid_pixels > 0:
                 mean_val = float(np.nanmean(patch))
                 health = get_health_category(mean_val, index_type)
-                
                 patches_list.append({
-                    'id': f"P{row}_{col}",
-                    'row': row,
-                    'col': col,
-                    'center_x': (x_start + x_end) // 2,
-                    'center_y': (y_start + y_end) // 2,
-                    'mean': round(mean_val, 4),
-                    'std': round(float(np.nanstd(patch)), 4),
-                    'min': round(float(np.nanmin(patch)), 4),
-                    'max': round(float(np.nanmax(patch)), 4),
-                    'health': health,
-                    'pixels': int(valid_pixels)
+                    'id': f"P{row}_{col}", 'mean': round(mean_val, 4),
+                    'health': health, 'pixels': int(valid_pixels)
                 })
-                
                 health_counts[health] = health_counts.get(health, 0) + 1
     
     total = len(patches_list)
-    health_summary = {
+    return patches_list, {
         'total_patches': total,
         'grid': f"{actual_rows}x{actual_cols}",
         'counts': health_counts,
         'percentages': {k: round(100 * v / total, 1) for k, v in health_counts.items()} if total > 0 else {}
     }
-    
-    # Log health distribution
-    logger.info("    • Health Distribution:")
-    for cat, count in health_counts.items():
-        pct = 100 * count / total if total > 0 else 0
-        bar = "█" * int(pct // 5) + "░" * (20 - int(pct // 5))
-        logger.info(f"      {cat:12s}: {bar} {pct:.1f}% ({count} patches)")
-    
-    return patches_list, health_summary
 
 # ============================================================================
 # HEATMAP GENERATION
 # ============================================================================
-def generate_heatmap_image(data: np.ndarray, index_type: str, gaussian_sigma: float, 
-                           show_boundary: bool, patches_list: list = None) -> tuple:
-    """Generate heatmap from pixel-wise index data."""
-    
+def generate_heatmap_image(data: np.ndarray, index_type: str, gaussian_sigma: float = 1.5,
+                           show_boundary: bool = True, is_stress: bool = False) -> tuple:
+    """Generate heatmap from index data."""
     valid_mask = ~np.isnan(data)
-    valid_pct = 100 * np.sum(valid_mask) / data.size
-    logger.info(f"    • Valid pixels: {np.sum(valid_mask):,} / {data.size:,} ({valid_pct:.1f}%)")
-    
     if not np.any(valid_mask):
         raise ValueError("No valid data pixels")
     
-    min_val = float(np.nanmin(data))
-    max_val = float(np.nanmax(data))
+    min_val, max_val = float(np.nanmin(data)), float(np.nanmax(data))
     mean_val = float(np.nanmean(data))
-    std_val = float(np.nanstd(data))
-    
-    logger.info(f"    • {index_type} Stats: min={min_val:.4f}, max={max_val:.4f}, mean={mean_val:.4f}, std={std_val:.4f}")
     
-    # Normalize
     data_norm = np.clip((data - min_val) / (max_val - min_val + 1e-8), 0, 1)
     data_norm = np.nan_to_num(data_norm, nan=0.5)
     
-    # Gaussian smoothing
     if gaussian_sigma > 0:
-        logger.info(f"    • Applying Gaussian smoothing (σ={gaussian_sigma})")
         data_norm = gaussian_filter(data_norm, sigma=gaussian_sigma)
     
-    # Create figure
     fig, ax = plt.subplots(figsize=(8, 8), dpi=100)
-    cmap = get_water_colormap() if index_type in ['NDWI', 'SMI'] else get_vegetation_colormap()
+    
+    if is_stress:
+        cmap = get_stress_colormap()
+    elif index_type in ['NDWI', 'SMI']:
+        cmap = get_water_colormap()
+    else:
+        cmap = get_vegetation_colormap()
+    
     im = ax.imshow(data_norm, cmap=cmap, interpolation='bilinear')
     
-    # Field boundary
     if show_boundary:
         h, w = data_norm.shape
-        rect = plt.Rectangle((w*0.02, h*0.02), w*0.96, h*0.96, fill=False, 
+        rect = plt.Rectangle((w*0.02, h*0.02), w*0.96, h*0.96, fill=False,
                               edgecolor='white', linewidth=2, linestyle='--', alpha=0.7)
         ax.add_patch(rect)
     
-    # Colorbar
     cbar = plt.colorbar(im, ax=ax, shrink=0.8, pad=0.02)
-    cbar.set_label(f'{index_type}', fontsize=10)
-    ticks = np.linspace(0, 1, 5)
-    cbar.set_ticks(ticks)
-    cbar.set_ticklabels([f'{min_val + t*(max_val-min_val):.2f}' for t in ticks])
+    cbar.set_label(f'{index_type}' if not is_stress else 'Stress Score', fontsize=10)
     
-    ax.set_title(f'{index_type} Heatmap', fontsize=14, fontweight='bold')
+    ax.set_title(f'{index_type} Heatmap' if not is_stress else 'Stress Heatmap', fontsize=14, fontweight='bold')
     ax.axis('off')
     
     buf = io.BytesIO()
@@ -300,10 +293,61 @@ def generate_heatmap_image(data: np.ndarray, index_type: str, gaussian_sigma: fl
     plt.close(fig)
     buf.seek(0)
     
-    img_b64 = base64.b64encode(buf.getvalue()).decode('utf-8')
-    logger.info(f"    • Image generated: {len(img_b64):,} bytes (base64)")
-    
-    return img_b64, min_val, max_val, mean_val, std_val
+    return base64.b64encode(buf.getvalue()).decode('utf-8'), min_val, max_val, mean_val
+
+# ============================================================================
+# LLM ANALYSIS (for risk metrics)
+# ============================================================================
+def run_llm_analysis(metric: str, stress_context: dict, indices_data: dict) -> dict:
+    """Call Gemini LLM with full context from stress detection."""
+    try:
+        import google.generativeai as genai
+        
+        api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            return {"level": "Unknown", "analysis": "GEMINI_API_KEY not set", "recommendations": []}
+        
+        genai.configure(api_key=api_key, transport='rest')
+        model = genai.GenerativeModel('gemini-flash-latest')
+        
+        # Format stress context
+        stress_text = format_stress_context(stress_context)
+        
+        # Create targeted prompt based on metric
+        prompt = f"""
+CROP STRESS ANALYSIS REQUEST
+
+{stress_text}
+
+METRIC TO ANALYZE: {metric.upper().replace('_', ' ')}
+
+Based on the stress detection results above, provide analysis for {metric}.
+
+Respond with ONLY a valid JSON object (no markdown):
+{{
+    "level": "Low" or "Moderate" or "High",
+    "analysis": "4-5 words describing the current state",
+    "temporal_trend": "Improving" or "Stable" or "Worsening",
+    "recommendations": ["action 1", "action 2"]
+}}
+"""
+        
+        response = model.generate_content(prompt)
+        response_text = response.text.strip()
+        
+        # Clean markdown if present
+        if response_text.startswith("```"):
+            lines = response_text.split("\n")
+            response_text = "\n".join(lines[1:-1])
+        if response_text.startswith("json"):
+            response_text = response_text[4:].strip()
+        
+        import json
+        return json.loads(response_text)
+        
+    except Exception as e:
+        logger.error(f"LLM analysis failed: {e}")
+        return {"level": "Moderate", "analysis": "Analysis unavailable", "recommendations": ["Manual inspection recommended"]}
 
 # ============================================================================
 # API ENDPOINTS
@@ -312,39 +356,42 @@ def generate_heatmap_image(data: np.ndarray, index_type: str, gaussian_sigma: fl
 async def root():
     return {
         "service": "AGROW Heatmap Service",
-        "version": "2.3.0",
-        "mode": "Pixel-wise + 100-200 patch analysis",
-        "indices": list(INDEX_FUNCTIONS.keys())
+        "version": "3.0.0",
+        "modes": {"pixelwise": list(PIXELWISE_METRICS.keys()), "llm": list(LLM_METRICS.keys())},
+        "all_metrics": ALL_METRICS
     }
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy"}
+    return {"status": "healthy", "metrics": ALL_METRICS}
 
 
 @app.post("/generate-heatmap", response_model=HeatmapResponse)
 async def generate_heatmap(request: HeatmapRequest):
-    """Generate heatmap with pixel-wise index calculation and patch analysis."""
+    """Generate heatmap - auto-detects mode based on metric."""
     
     req_id = datetime.now().strftime("%H%M%S")
     
-    log_section(f"REQUEST [{req_id}]")
-    log_detail("Location", f"({request.center_lat:.6f}, {request.center_lon:.6f})")
-    log_detail("Field Size", f"{request.field_size_hectares} hectares")
-    log_detail("Index", request.index_type)
-    log_detail("Target Patches", request.target_patches)
+    # Validate metric
+    if request.metric not in ALL_METRICS:
+        raise HTTPException(400, f"Invalid metric: {request.metric}. Valid: {ALL_METRICS}")
+    
+    # Determine mode
+    is_llm_mode = request.metric in LLM_METRICS
+    mode = "llm" if is_llm_mode else "pixelwise"
     
-    if request.index_type not in INDEX_FUNCTIONS:
-        raise HTTPException(400, f"Invalid index: {request.index_type}")
+    log_section(f"REQUEST [{req_id}] - {mode.upper()} MODE")
+    log_detail("Metric", request.metric)
+    log_detail("Location", f"({request.center_lat:.6f}, {request.center_lon:.6f})")
+    log_detail("Field Size", f"{request.field_size_hectares} ha")
     
     try:
-        # STEP 1: Config
-        log_step(1, 5, "Loading Sentinel Hub config")
+        # Step 1: Config
+        log_step(1, 6 if is_llm_mode else 5, "Loading Sentinel Hub config")
         config = get_sh_config()
-        log_detail("Client ID", f"{config.sh_client_id[:8]}..." if config.sh_client_id else "NOT SET")
         
-        # STEP 2: Bounding Box
-        log_step(2, 5, "Calculating bounding box")
+        # Step 2: Bounding Box
+        log_step(2, 6 if is_llm_mode else 5, "Calculating bounding box")
         radius_km = np.sqrt(request.field_size_hectares / 100) / 2
         lat_off = radius_km / 111
         lon_off = radius_km / (111 * np.cos(np.radians(request.center_lat)))
@@ -355,14 +402,12 @@ async def generate_heatmap(request: HeatmapRequest):
         ), crs=CRS.WGS84)
         
         size = bbox_to_dimensions(bbox, resolution=10)
-        log_detail("Image Size", f"{size[0]}×{size[1]} pixels @ 10m")
-        log_detail("Coverage", f"{size[0]*10}m × {size[1]*10}m")
+        log_detail("Image Size", f"{size[0]}×{size[1]} pixels")
         
-        # STEP 3: Fetch Data
-        log_step(3, 5, "Fetching Sentinel-2 data")
+        # Step 3: Fetch Data
+        log_step(3, 6 if is_llm_mode else 5, "Fetching Sentinel-2 data")
         end_date = datetime.now()
         start_date = end_date - timedelta(days=30)
-        log_detail("Date Range", f"{start_date.strftime('%Y-%m-%d')} → {end_date.strftime('%Y-%m-%d')}")
         
         SENTINEL2 = DataCollection.define(
             "S2_CDSE", api_id="sentinel-2-l2a",
@@ -382,51 +427,130 @@ async def generate_heatmap(request: HeatmapRequest):
         )
         
         data = sh_request.get_data()[0]
-        
         if data is None or data.size == 0:
             raise HTTPException(404, "No satellite data available")
         
         log_detail("Data Shape", f"{data.shape}")
-        log_detail("Data Type", f"{data.dtype}")
         
-        # STEP 4: Calculate Index (PIXEL-WISE)
-        log_step(4, 5, f"Calculating {request.index_type} (pixel-wise)")
+        # Get image data (remove dataMask)
         img_data = data[:, :, :12]
-        index_func = INDEX_FUNCTIONS[request.index_type]
-        index_data = index_func(img_data)
-        
-        log_detail("Index Shape", f"{index_data.shape}")
-        log_detail("Index Range", f"[{np.nanmin(index_data):.4f}, {np.nanmax(index_data):.4f}]")
-        log_detail("Index Mean", f"{np.nanmean(index_data):.4f}")
-        
-        # STEP 5: Patch Analysis & Heatmap
-        log_step(5, 5, "Analyzing patches & generating heatmap")
-        patches_list, health_summary = analyze_patches(index_data, request.index_type, request.target_patches)
         
-        img_b64, min_v, max_v, mean_v, std_v = generate_heatmap_image(
-            index_data, request.index_type, request.gaussian_sigma,
-            request.show_field_boundary, patches_list
-        )
-        
-        log_section(f"SUCCESS [{req_id}]")
-        logger.info(f"  Generated {request.index_type} heatmap with {len(patches_list)} patches")
+        # ================================================================
+        # PIXEL-WISE MODE
+        # ================================================================
+        if not is_llm_mode:
+            index_type = PIXELWISE_METRICS[request.metric]
+            
+            log_step(4, 5, f"Calculating {index_type} (pixel-wise)")
+            index_func = INDEX_FUNCTIONS[index_type]
+            index_data = index_func(img_data)
+            
+            log_step(5, 5, "Generating heatmap & patch analysis")
+            patches_list, health_summary = analyze_patches_pixelwise(index_data, index_type)
+            img_b64, min_v, max_v, mean_v = generate_heatmap_image(
+                index_data, index_type, request.gaussian_sigma, request.show_field_boundary
+            )
+            
+            log_section(f"SUCCESS [{req_id}]")
+            
+            return HeatmapResponse(
+                success=True,
+                metric=request.metric,
+                mode="pixelwise",
+                index_used=index_type,
+                min_value=min_v,
+                max_value=max_v,
+                mean_value=mean_v,
+                image_base64=img_b64,
+                timestamp=datetime.now().isoformat(),
+                image_date=end_date.strftime('%Y-%m-%d'),
+                image_size=f"{size[0]}x{size[1]}",
+                num_patches=len(patches_list),
+                health_summary=health_summary
+            )
         
-        return HeatmapResponse(
-            success=True,
-            index_type=request.index_type,
-            min_value=min_v,
-            max_value=max_v,
-            mean_value=mean_v,
-            std_value=std_v,
-            image_base64=img_b64,
-            timestamp=datetime.now().isoformat(),
-            image_date=end_date.strftime('%Y-%m-%d'),
-            image_size=f"{size[0]}x{size[1]}",
-            num_patches=len(patches_list),
-            patch_grid=health_summary['grid'],
-            patches=patches_list[:50],  # Return 50 patches
-            health_summary=health_summary
-        )
+        # ================================================================
+        # LLM MODE (CNN + Clustering + LLM)
+        # ================================================================
+        else:
+            metric_config = LLM_METRICS[request.metric]
+            primary_index = metric_config['primary_index']
+            
+            log_step(4, 6, f"Running CNN stress detection (patch=4, stride=2)")
+            
+            # Reshape data for stress detection: (1, h, w, bands) -> (time, h, w, bands)
+            all_images = img_data[np.newaxis, :, :, :]  # Add time dimension
+            
+            # Preprocess for stress model
+            patches, patch_coords, metadata = preprocess_for_model(
+                all_images, patch_size=4, stride=2
+            )
+            
+            log_detail("Patches extracted", f"{len(patch_coords)}")
+            log_detail("Patch shape", f"{patches.shape}")
+            
+            # Build and run stress model
+            stress_model = StressDetectionModel(
+                patch_size=metadata['patch_size'],
+                num_bands=metadata['num_bands'],
+                num_timestamps=1,
+                spatial_embedding_dim=64,
+                temporal_embedding_dim=64
+            )
+            
+            stress_results = stress_model.predict(patches, n_clusters=3, contamination=0.1)
+            
+            # Prepare LLM context
+            stress_context = prepare_llm_context(stress_results, patch_coords, patches, metadata)
+            
+            log_detail("Overall stress score", f"{stress_results['stress_scores'].mean():.3f}")
+            log_detail("Clusters", f"{stress_results['n_clusters']}")
+            
+            log_step(5, 6, f"Running LLM analysis for {request.metric}")
+            
+            # Calculate primary index for visualization
+            index_func = INDEX_FUNCTIONS[primary_index]
+            index_data = index_func(img_data)
+            
+            # Run LLM analysis
+            llm_result = run_llm_analysis(request.metric, stress_context, {'primary': index_data})
+            
+            log_step(6, 6, "Generating heatmap")
+            
+            # Generate stress-based heatmap
+            # Create stress map from patch scores
+            h, w = img_data.shape[:2]
+            stress_map = np.zeros((h, w))
+            for i, (py, px) in enumerate(patch_coords):
+                stress_map[py:py+4, px:px+4] = stress_results['stress_scores'][i]
+            
+            img_b64, min_v, max_v, mean_v = generate_heatmap_image(
+                stress_map, "Stress", request.gaussian_sigma, request.show_field_boundary, is_stress=True
+            )
+            
+            # Get cluster distribution
+            cluster_dist = stress_context['field_statistics']['stress_distribution']
+            
+            log_section(f"SUCCESS [{req_id}]")
+            
+            return HeatmapResponse(
+                success=True,
+                metric=request.metric,
+                mode="llm",
+                index_used=primary_index,
+                min_value=min_v,
+                max_value=max_v,
+                mean_value=mean_v,
+                image_base64=img_b64,
+                timestamp=datetime.now().isoformat(),
+                image_date=end_date.strftime('%Y-%m-%d'),
+                image_size=f"{size[0]}x{size[1]}",
+                level=llm_result.get('level', 'Unknown'),
+                analysis=llm_result.get('analysis', ''),
+                stress_score=float(stress_results['stress_scores'].mean()),
+                cluster_distribution=cluster_dist,
+                recommendations=llm_result.get('recommendations', [])
+            )
         
     except HTTPException:
         raise
@@ -439,11 +563,11 @@ async def generate_heatmap(request: HeatmapRequest):
 @app.get("/generate-heatmap-image")
 async def get_heatmap_image(
     center_lat: float, center_lon: float, field_size_hectares: float,
-    index_type: str = "NDVI", gaussian_sigma: float = 1.5
+    metric: str = "soil_moisture", gaussian_sigma: float = 1.5
 ):
     request = HeatmapRequest(
         center_lat=center_lat, center_lon=center_lon,
-        field_size_hectares=field_size_hectares, index_type=index_type,
+        field_size_hectares=field_size_hectares, metric=metric,
         gaussian_sigma=gaussian_sigma
     )
     response = await generate_heatmap(request)

llm_analysis.py

@@ -0,0 +1,422 @@
+"""
+LLM Integration for Vegetation Indices Analysis
+================================================
+
+This module integrates with Google Gemini to analyze vegetation indices
+and provide comprehensive soil and crop insights.
+"""
+
+import os
+import json
+import numpy as np
+import google.generativeai as genai
+from typing import Dict, Any
+
+def configure_gemini():
+    """Configure Gemini API with key from environment."""
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if not api_key:
+        raise ValueError("GEMINI_API_KEY not found in environment variables")
+    genai.configure(api_key=api_key, transport='rest')
+    return genai.GenerativeModel('gemini-flash-latest')
+
+def prepare_indices_context(summary_report: Dict, crop_type: str, farmer_context: Dict, 
+                           temporal_stats: Dict = None) -> str:
+    """
+    Prepare a comprehensive context string for the LLM including temporal statistics.
+    
+    Args:
+        summary_report: Dictionary with all indices data
+        crop_type: Type of crop being analyzed
+        farmer_context: Farmer profile information
+        temporal_stats: Dictionary with temporal statistics (optional)
+        
+    Returns:
+        Formatted context string
+    """
+    context = f"""
+CROP MONITORING ANALYSIS REQUEST
+
+CROP INFORMATION:
+- Crop Type: {crop_type}
+- Analysis Period: {summary_report['dates'][0]} to {summary_report['dates'][-1]}
+- Number of Images Analyzed: {summary_report['num_images']}
+
+FARMER CONTEXT:
+- Role: {farmer_context.get('role', 'Unknown')}
+- Experience: {farmer_context.get('years_farming', 'Unknown')} years
+- Irrigation Method: {farmer_context.get('irrigation_method', 'Unknown')}
+- Farming Goal: {farmer_context.get('farming_goal', 'Unknown')}
+
+VEGETATION INDICES DATA (ALL 13 INDICES):
+"""
+    
+    for index_name, stats in summary_report['indices'].items():
+        context += f"\n{index_name}:"
+        context += f"\n  - Latest Mean Value: {stats['latest']['mean']:.4f}"
+        context += f"\n  - Maximum in Field: {stats['max_in_field']:.4f}"
+        context += f"\n  - Minimum in Field: {stats['min_in_field']:.4f}"
+        context += f"\n  - Temporal Change (Latest - Oldest): {stats['change']:+.4f}"
+        context += f"\n  - Temporal Trend (All Values): {stats['mean_values_over_time']}"
+    
+    
+    # Add temporal statistics if provided
+    if temporal_stats:
+        context += "\n\nTEMPORAL STATISTICS (FEATURE ENGINEERING):\n"
+        for index_name, t_stats in temporal_stats.items():
+            context += f"\n{index_name} Temporal Features:"
+            
+            # Mean and std over time
+            mean_spatial = float(np.nanmean(t_stats['mean_over_time']))
+            std_spatial = float(np.nanmean(t_stats['std_over_time']))
+            context += f"\n  - Spatial Mean (averaged over time): {mean_spatial:.4f}"
+            context += f"\n  - Spatial Std (averaged over time): {std_spatial:.4f}"
+            
+            # Max and min over time
+            max_val = float(np.nanmax(t_stats['max_over_time']))
+            min_val = float(np.nanmin(t_stats['min_over_time']))
+            range_val = float(np.nanmean(t_stats['range']))
+            context += f"\n  - Maximum Value Over Time: {max_val:.4f}"
+            context += f"\n  - Minimum Value Over Time: {min_val:.4f}"
+            context += f"\n  - Average Range (Max-Min): {range_val:.4f}"
+            
+            # Temporal trend
+            trend_mean = float(np.nanmean(t_stats['temporal_trend']))
+            context += f"\n  - Average Temporal Trend: {trend_mean:+.4f}"
+            
+            # Rolling average if available
+            if 'rolling_avg_3' in t_stats:
+                latest_rolling = float(np.nanmean(t_stats['rolling_avg_3'][-1]))
+                context += f"\n  - Latest Rolling Average (3-period): {latest_rolling:.4f}"
+    
+    return context
+
+def format_stress_context(stress_context: Dict) -> str:
+    """
+    Format stress detection results for LLM prompt.
+    
+    Args:
+        stress_context: Dictionary with stress detection results
+        
+    Returns:
+        Formatted string with stress patterns, clusters, and anomalies
+    """
+    if not stress_context:
+        return ""
+        
+    c = "\nDEEP LEARNING STRESS DETECTION RESULTS:\n"
+    c += "=======================================\n"
+    
+    # Field Statistics
+    fs = stress_context.get('field_statistics', {})
+    c += f"Overall Field Stress Score: {fs.get('overall_stress', {}).get('mean', 0):.3f} (0=Healthy, 1=Severe Stress)\n"
+    c += f"Stress Category Distribution: {fs.get('stress_distribution', {})}\n"
+    
+    # Cluster Statistics (Patterns)
+    c += "\nIDENTIFIED CLUSTERING PATTERNS (SPATIAL-TEMPORAL BEHAVIOR):\n"
+    for cluster in stress_context.get('cluster_statistics', []):
+        c += f"  * Cluster {cluster['cluster_id']} ({cluster['percentage']:.1f}% of field):\n"
+        c += f"    - Average Stress Score: {cluster['stress_score']['mean']:.3f}\n"
+        c += f"    - Stress Variability (Std): {cluster['stress_score']['std']:.3f}\n"
+        # Add key band stats if available to explain *why* it's a cluster
+        if 'band_statistics' in cluster:
+            c += "    - Key Spectral Characteristics:\n"
+            # Just show a few key bands to keep it concise
+            for band in ['B04', 'B08', 'B11']: # Red, NIR, SWIR
+                if band in cluster['band_statistics']:
+                    val = cluster['band_statistics'][band]['mean']
+                    c += f"      {band}: {val:.4f}\n"
+        
+        # Add temporal trends if available
+        if 'temporal_trends' in cluster:
+            c += "    - Temporal Trends (Change over analysis period):\n"
+            for band in ['B04', 'B08', 'B11']: # Red, NIR, SWIR
+                if band in cluster['temporal_trends']:
+                    trend = cluster['temporal_trends'][band]
+                    c += f"      {band}: {trend['trend_direction']} ({trend['change']:+.4f})\n"
+
+    # Anomaly Information
+    anom = stress_context.get('anomaly_information', {})
+    c += f"\nANOMALY DETECTION (UNUSUAL PATTERNS):\n"
+    c += f"- Total Anomalies Detected: {anom.get('total_anomalies', 0)} patches ({anom.get('anomaly_percentage', 0):.1f}% of field)\n"
+    if anom.get('anomaly_patches'):
+        c += "- Sample Anomalies:\n"
+        for p in anom['anomaly_patches'][:3]:
+            c += f"  * Patch at {p['coordinates']}: Stress={p['stress_score']:.3f}, Category={p['stress_category']}\n"
+            
+    return c
+
+def analyze_with_llm(summary_report: Dict, crop_type: str, farmer_context: Dict, 
+                     center_lat: float, center_lon: float, field_size_hectares: float,
+                     temporal_stats: Dict = None, stress_context: Dict = None) -> Dict[str, Any]:
+    """
+    Analyze vegetation indices using Gemini LLM and extract soil insights.
+    
+    Args:
+        summary_report: Dictionary with all indices data
+        crop_type: Type of crop
+        farmer_context: Farmer profile information
+        center_lat: Latitude
+        center_lon: Longitude
+        field_size_hectares: Field size
+        temporal_stats: Dictionary with temporal statistics
+        stress_context: Dictionary with stress detection results (clustering, anomalies)
+    
+    Returns:
+        Dictionary with structured LLM analysis results
+    """
+    model = configure_gemini()
+    
+    # Prepare context with temporal statistics
+    indices_context = prepare_indices_context(summary_report, crop_type, farmer_context, temporal_stats)
+    
+    # Prepare stress context
+    stress_text = format_stress_context(stress_context)
+    
+    # Create prompt for LLM
+    # Using concatenation to avoid potential f-string parsing issues with long multi-line strings
+    prompt = f"{indices_context}\n\n{stress_text}\n\n"
+    prompt += "FIELD METADATA:\n"
+    # Add location details
+    prompt += f"- Location: Latitude {center_lat:.4f}, Longitude {center_lon:.4f}\n"
+    prompt += f"- Field Size: {field_size_hectares:.2f} hectares\n\n"
+    
+    prompt += """Based on the vegetation indices data AND the deep learning stress detection results above, 
+provide a comprehensive analysis.
+
+Use the cluster patterns to identify distinct zones in the field.
+Use the anomaly detection results to pinpoint specific problem areas.
+Analyze the temporal trends in each cluster to determine if stress is worsening or recovering.
+Combine the spectral indices (NDVI, NDWI, etc.) with the stress scores to explain the *cause* of stress.
+
+You MUST respond with a valid JSON object (no markdown, no code blocks) with EXACTLY this structure:
+
+{
+  "soil_moisture": {
+    "level": "Low" or "Moderate" or "High",
+    "maximum_value": <float>,
+    "minimum_value": <float>,
+    "analysis": "Analyse mainly SMI patterns,spatial and temporal and variation,then check all other information along with the context given to give four words,not necessarily full sentences,but capture the sense which are very impactful,very simple to understand about the current soil moisture content of the overall field"
+  },
+  "soil_salinity": {
+    "level": "Low" or "Moderate" or "High",
+    "analysis": "Analyse mainly NDSI patterns,spatial and temporal and variation,then check all other information along with the context given to give four words,not necessarily full sentences,but capture the sense which are very impactful,very simple to understand about the current soil salinity of the overall field"
+  },
+  "organic_matter": {
+    "level": "Low" or "Moderate" or "High",
+    "analysis": "Analyse mainly SOMI patterns,spatial and temporal and variation,then check all other information along with the context given to give four words,not necessarily full sentences,but capture the sense which are very impactful,very simple to understand about the current soil organic matter content of the overall field"
+  },
+  "soil_fertility": {
+    "level": "Low" or "Moderate" or "High",
+    "analysis": "Analyse mainly SFI patterns,spatial and temporal and variation,then check all other information along with the context given to give four words,not necessarily full sentences,but capture the sense which are very impactful,very simple to understand about the current soil fertility of the overall field"
+  },
+  "Pest Rsk": {
+    "level": "Low" or "Moderate" or "High",
+    "analysis": "Analyse field patterns,temporal and spatial health variations very meticulously,catch the pattern and use the indices as additional confirmation to give accurate pest risk diseases and give 4 words not necessarily connected sentences,but capture the sense which are very impactful,very simple to understand about current pest risk or its spreading pattern"
+  },
+  "Nutrient Stress": {
+    "level": "Low" or "Moderate" or "High",
+    "analysis":"Analyse field patterns,temporal and spatial health variations very meticulously,catch the pattern and use NDRE,NDVI,MCARI,OSAVI as primary indices whose trends both spatial and temporal should be closely analysed and four words not neccesarily connected sentences,but capture the sense which are very impactful,very simple to understand about current nutrient stress"
+  },
+  "Disease Risk": {
+    "level": "Low" or "Moderate" or "High",
+    "analysis": "Analyse field patterns,temporal and spatial health variations very meticulously,catch the pattern be closely analysed and four words not neccesarily connected sentences,but capture the sense which are very impactful,very simple to understand about current disease rsik of the entire field,preferably a possible attacking agent/pest name"
+  },
+  "Stress Zone": {
+    "level": "Low" or "Moderate" or "Alert",
+    "analysis": "Analyse field patterns,temporal and spatial health variations very meticulously,catch the pattern be closely analysed and four words not neccesarily connected sentences,but capture the sense which are very impactful,very simple to understand about current stress zones in the entire field,the location,intensity,duration of stress or stress spread pattern in the field "
+  },
+  "overall_health": {
+    "status": "poor" or "fair" or "good" or "excellent",
+    "key_concerns": ["concern1", "concern2"],
+    "recommendations": ["recommendation1", "recommendation2"]
+  }
+}
+
+IMPORTANT GUIDELINES:
+- For soil_moisture.maximum_value and minimum_value, use the SMI index values from the data
+- For soil_salinity.trend, provide EXACTLY four words describing the trend based on SASI values
+- For organic_matter.status, provide EXACTLY four words based on SOMI index values
+- For soil_fertility.status, provide EXACTLY four words (not a sentence) about soil health based on SFI values
+- For vegetation_stress.status, provide EXACTLY four words based on NDVI, EVI, NDRE temporal patterns
+- For photosynthetic_stress.status, provide EXACTLY four words based on PRI, PSRI, RECI values
+- For hotspot_detection.description, provide LESS THAN 6 words about stress direction and intensity
+- For moisture_zones.description, provide NOT MORE THAN 6 words about moisture variation and trend
+- Use spatial statistics (max, min, range) to identify hotspots and zones
+- Consider temporal trends to detect spreading patterns
+- Base your analysis on the actual index values provided
+- Provide actionable insights relevant to the farmer's context
+
+Return ONLY the JSON object, no additional text.
+"""
+    
+    # Get LLM response
+    response = model.generate_content(prompt)
+    response_text = response.text.strip()
+    
+    # Remove markdown code blocks if present
+    if response_text.startswith("```"):
+        lines = response_text.split("\n")
+        response_text = "\n".join(lines[1:-1])
+    if response_text.startswith("json"):
+        response_text = response_text[4:].strip()
+    
+    # Parse JSON response
+    try:
+        analysis = json.loads(response_text)
+        return analysis
+    except json.JSONDecodeError as e:
+        print(f"Error parsing LLM response: {e}")
+        print(f"Response text: {response_text}")
+        # Return fallback structure
+        return {
+            "soil_moisture": {
+                "level": "Moderate",
+                "maximum_value": summary_report['indices']['SMI']['max_in_field'],
+                "minimum_value": summary_report['indices']['SMI']['min_in_field'],
+                "analysis": "Unable to parse LLM response"
+            },
+            "soil_salinity": {
+                "level": "Moderate",
+                "analysis": "Unable to parse LLM response"
+            },
+            "organic_matter": {
+                "level": "Moderate",
+                "analysis": "Unable to parse LLM response"
+            },
+            "soil_fertility": {
+                "level": "Moderate",
+                "analysis": "Unable to parse LLM response"
+            },
+            "pest_risk": {
+                "level": "Moderate",
+                "analysis": "Unable to parse LLM response"
+            },
+            "disease_risk": {
+                "level": "Moderate",
+                "analysis": "Unable to parse LLM response"
+            },
+            "nutrient_stress": {
+                "level": "Moderate",
+                "analysis": "Unable to parse LLM response"
+            },
+            "stress_zone": {
+                "level": "Moderate",
+                "analysis": "Unable to parse LLM response"
+            },
+            "overall_health": {
+                "status": "fair",
+                "key_concerns": ["Analysis unavailable"],
+                "recommendations": ["Please review indices manually"]
+            },
+            "overall_biorisk": 0.5,
+            "overall_soil_health": 0.5
+        }
+
+def format_llm_output(analysis: Dict) -> str:
+    """
+    Format LLM analysis into a readable report.
+    
+    Args:
+        analysis: Dictionary with LLM analysis results
+        
+    Returns:
+        Formatted string report
+    """
+    report = """
++================================================================+
+|              LLM ANALYSIS - SOIL & CROP INSIGHTS               |
++================================================================+
+
+SOIL MOISTURE ANALYSIS:
+----------------------------------------------------------------
+"""
+    
+    sm = analysis['soil_moisture']
+    report += f"  Level: {sm['level'].upper()}\n"
+    report += f"  Maximum Value: {sm['maximum_value']:.4f}\n"
+    report += f"  Minimum Value: {sm['minimum_value']:.4f}\n"
+    report += f"  Analysis: {sm['analysis']}\n"
+    
+    report += """
+SOIL SALINITY ANALYSIS:
+----------------------------------------------------------------
+"""
+    
+    ss = analysis['soil_salinity']
+    report += f"  Level: {ss['level'].upper()}\n"
+    report += f"  Analysis: {ss['analysis']}\n"
+    
+    report += """
+ORGANIC MATTER ANALYSIS:
+----------------------------------------------------------------
+"""
+    
+    om = analysis['organic_matter']
+    report += f"  Level: {om['level'].upper()}\n"
+    report += f"  Analysis: {om['analysis']}\n"
+    
+    report += """
+SOIL FERTILITY ANALYSIS:
+----------------------------------------------------------------
+"""
+    
+    sf = analysis['soil_fertility']
+    report += f"  Level: {sf['level'].upper()}\n"
+    report += f"  Analysis: {sf['analysis']}\n"
+    
+
+    
+    report += """
+PEST RISK ANALYSIS:
+----------------------------------------------------------------
+"""
+    
+    pr = analysis.get('pest_risk', {'level': 'unknown', 'analysis': 'No data'})
+    report += f"  Level: {pr['level'].upper()}\n"
+    report += f"  Analysis: {pr['analysis']}\n"
+    
+    report += """
+DISEASE RISK ANALYSIS:
+----------------------------------------------------------------
+"""
+    
+    dr = analysis.get('disease_risk', {'level': 'unknown', 'analysis': 'No data'})
+    report += f"  Level: {dr['level'].upper()}\n"
+    report += f"  Analysis: {dr['analysis']}\n"
+    
+    report += """
+NUTRIENT STRESS ANALYSIS:
+----------------------------------------------------------------
+"""
+    
+    ns = analysis.get('nutrient_stress', {'level': 'unknown', 'analysis': 'No data'})
+    report += f"  Level: {ns['level'].upper()}\n"
+    report += f"  Analysis: {ns['analysis']}\n"
+
+    report += """
+STRESS ZONE ANALYSIS:
+----------------------------------------------------------------
+"""
+    
+    sz = analysis.get('stress_zone', {'level': 'unknown', 'analysis': 'No data'})
+    report += f"  Level: {sz['level'].upper()}\n"
+    report += f"  Analysis: {sz['analysis']}\n"
+    
+    report += """
+OVERALL CROP HEALTH:
+----------------------------------------------------------------
+"""
+    
+    oh = analysis['overall_health']
+    report += f"  Status: {oh['status'].upper()}\n"
+    report += f"\n  Key Concerns:\n"
+    for concern in oh['key_concerns']:
+        report += f"    • {concern}\n"
+    report += f"\n  Recommendations:\n"
+    for rec in oh['recommendations']:
+        report += f"    • {rec}\n"
+    
+    report += "\n" + "=" * 64 + "\n"
+    
+    return report

requirements.txt

@@ -7,3 +7,6 @@ matplotlib>=3.7.0
 Pillow>=9.0.0
 sentinelhub>=3.9.0
 python-dotenv>=1.0.0
+tensorflow>=2.12.0
+scikit-learn>=1.3.0
+google-generativeai>=0.3.0

stress_detection_model.py

@@ -0,0 +1,475 @@
+"""
+Stress Detection Model
+=======================
+
+Deep learning model for crop stress detection using spatial-temporal encoding.
+Architecture: Spatial CNN → Temporal LSTM → Clustering → Anomaly Detection
+"""
+
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+from sklearn.cluster import KMeans
+from sklearn.ensemble import IsolationForest
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import silhouette_score
+from typing import Tuple, Dict, List
+import warnings
+warnings.filterwarnings('ignore')
+
+
+class SpatialEncoder(keras.Model):
+    """
+    CNN-based spatial feature extractor.
+    Processes each timestamp independently to extract spatial features.
+    """
+    
+    def __init__(self, embedding_dim=128):
+        super(SpatialEncoder, self).__init__()
+        
+        # Convolutional layers
+        self.conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')
+        self.bn1 = layers.BatchNormalization()
+        self.pool1 = layers.MaxPooling2D((2, 2))
+        self.dropout1 = layers.Dropout(0.25)
+        
+        self.conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')
+        self.bn2 = layers.BatchNormalization()
+        self.pool2 = layers.MaxPooling2D((2, 2))
+        self.dropout2 = layers.Dropout(0.25)
+        
+        self.conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')
+        self.bn3 = layers.BatchNormalization()
+        
+        # Global pooling and dense layers
+        self.global_pool = layers.GlobalAveragePooling2D()
+        self.dense1 = layers.Dense(256, activation='relu')
+        self.dropout3 = layers.Dropout(0.3)
+        self.dense2 = layers.Dense(embedding_dim, activation='relu')
+        
+    def call(self, x, training=False):
+        # x shape: (batch, height, width, channels)
+        x = self.conv1(x)
+        x = self.bn1(x, training=training)
+        x = self.pool1(x)
+        x = self.dropout1(x, training=training)
+        
+        x = self.conv2(x)
+        x = self.bn2(x, training=training)
+        x = self.pool2(x)
+        x = self.dropout2(x, training=training)
+        
+        x = self.conv3(x)
+        x = self.bn3(x, training=training)
+        
+        x = self.global_pool(x)
+        x = self.dense1(x)
+        x = self.dropout3(x, training=training)
+        x = self.dense2(x)
+        
+        return x  # (batch, embedding_dim)
+
+
+class TemporalEncoder(keras.Model):
+    """
+    LSTM-based temporal feature extractor.
+    Processes sequence of spatial embeddings to capture temporal patterns.
+    """
+    
+    def __init__(self, embedding_dim=128, lstm_units=64):
+        super(TemporalEncoder, self).__init__()
+        
+        self.lstm = layers.Bidirectional(
+            layers.LSTM(lstm_units, return_sequences=False, dropout=0.2)
+        )
+        self.dense = layers.Dense(embedding_dim, activation='relu')
+        
+    def call(self, x, training=False):
+        # x shape: (batch, time, spatial_embedding_dim)
+        x = self.lstm(x, training=training)
+        x = self.dense(x)
+        return x  # (batch, embedding_dim)
+
+
+class StressDetectionModel:
+    """
+    Complete stress detection pipeline with spatial-temporal encoding,
+    clustering, and anomaly detection.
+    """
+    
+    def __init__(self, patch_size=16, num_bands=8, num_timestamps=10,
+                 spatial_embedding_dim=128, temporal_embedding_dim=128):
+        self.patch_size = patch_size
+        self.num_bands = num_bands
+        self.num_timestamps = num_timestamps
+        self.spatial_embedding_dim = spatial_embedding_dim
+        self.temporal_embedding_dim = temporal_embedding_dim
+        
+        # Build encoders
+        self.spatial_encoder = SpatialEncoder(embedding_dim=spatial_embedding_dim)
+        self.temporal_encoder = TemporalEncoder(
+            embedding_dim=temporal_embedding_dim,
+            lstm_units=64
+        )
+        
+        # Build spatial encoder input
+        self.spatial_encoder.build((None, patch_size, patch_size, num_bands))
+        
+        # Clustering and anomaly detection (fitted during inference)
+        self.kmeans = None
+        self.anomaly_detector = None
+        self.scaler = StandardScaler()
+        
+    def encode_spatial_features(self, patches: np.ndarray) -> np.ndarray:
+        """
+        Extract spatial features from all patches and timestamps.
+        
+        Args:
+            patches: Array of shape (num_patches, time, height, width, bands)
+            
+        Returns:
+            spatial_embeddings: Array of shape (num_patches, time, spatial_embedding_dim)
+        """
+        num_patches, time, height, width, bands = patches.shape
+        
+        # Reshape to process all patches and timestamps together
+        # (num_patches * time, height, width, bands)
+        reshaped = patches.reshape(-1, height, width, bands)
+        
+        # Extract spatial features
+        spatial_features = self.spatial_encoder(reshaped, training=False).numpy()
+        
+        # Reshape back to (num_patches, time, embedding_dim)
+        spatial_embeddings = spatial_features.reshape(
+            num_patches, time, self.spatial_embedding_dim
+        )
+        
+        return spatial_embeddings
+    
+    def encode_temporal_features(self, spatial_embeddings: np.ndarray) -> np.ndarray:
+        """
+        Extract temporal features from spatial embeddings.
+        
+        Args:
+            spatial_embeddings: Array of shape (num_patches, time, spatial_embedding_dim)
+            
+        Returns:
+            temporal_embeddings: Array of shape (num_patches, temporal_embedding_dim)
+        """
+        temporal_embeddings = self.temporal_encoder(
+            spatial_embeddings, training=False
+        ).numpy()
+        
+        return temporal_embeddings
+    
+    def cluster_stress_patterns(self, embeddings: np.ndarray, n_clusters=4) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Cluster embeddings into stress categories and compute stress scores.
+        
+        Args:
+            embeddings: Array of shape (num_patches, embedding_dim)
+            n_clusters: Number of clusters (4: high, moderate, low, noise)
+            
+        Returns:
+            cluster_labels: Cluster assignment for each patch
+            stress_scores: Normalized stress scores in [0, 1]
+        """
+        # Standardize embeddings
+        embeddings_scaled = self.scaler.fit_transform(embeddings)
+        
+        # K-Means clustering
+        self.kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
+        cluster_labels = self.kmeans.fit_predict(embeddings_scaled)
+        
+        # Compute stress scores based on distance to cluster centers
+        distances = self.kmeans.transform(embeddings_scaled)
+        
+        # For each patch, compute stress score as weighted distance to all clusters
+        # Normalize to [0, 1] range
+        stress_scores = np.min(distances, axis=1)  # Distance to nearest cluster
+        stress_scores = 1 - (stress_scores - stress_scores.min()) / (stress_scores.max() - stress_scores.min() + 1e-10)
+        
+        # Alternative: Use cluster centers to assign stress levels
+        # Identify which cluster represents highest stress (largest distance from origin)
+        cluster_stress_levels = np.linalg.norm(self.kmeans.cluster_centers_, axis=1)
+        cluster_stress_levels = (cluster_stress_levels - cluster_stress_levels.min()) / \
+                               (cluster_stress_levels.max() - cluster_stress_levels.min() + 1e-10)
+        
+        # Assign stress score based on cluster membership
+        stress_scores = cluster_stress_levels[cluster_labels]
+        
+        return cluster_labels, stress_scores
+    
+    def detect_anomalies(self, embeddings: np.ndarray, contamination=0.1) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Detect anomalous stress patterns using Isolation Forest.
+        
+        Args:
+            embeddings: Array of shape (num_patches, embedding_dim)
+            contamination: Expected proportion of anomalies
+            
+        Returns:
+            anomaly_labels: 1 for normal, -1 for anomaly
+            anomaly_scores: Anomaly scores (lower = more anomalous)
+        """
+        self.anomaly_detector = IsolationForest(
+            contamination=contamination,
+            random_state=42
+        )
+        anomaly_labels = self.anomaly_detector.fit_predict(embeddings)
+        anomaly_scores = self.anomaly_detector.score_samples(embeddings)
+        
+        return anomaly_labels, anomaly_scores
+    
+    def predict(self, patches: np.ndarray, n_clusters=4, contamination=0.1) -> Dict:
+        """
+        Complete stress detection pipeline.
+        
+        Args:
+            patches: Array of shape (num_patches, time, height, width, bands)
+            n_clusters: Number of stress clusters
+            contamination: Expected proportion of anomalies
+            
+        Returns:
+            results: Dictionary with all predictions and embeddings
+        """
+        # Step 1: Spatial encoding
+        spatial_embeddings = self.encode_spatial_features(patches)
+        
+        # Step 2: Temporal encoding
+        temporal_embeddings = self.encode_temporal_features(spatial_embeddings)
+        
+        # Step 3: Clustering
+        cluster_labels, stress_scores = self.cluster_stress_patterns(
+            temporal_embeddings, n_clusters=n_clusters
+        )
+        
+        # Step 4: Anomaly detection
+        anomaly_labels, anomaly_scores = self.detect_anomalies(temporal_embeddings, contamination=contamination)
+        
+        return {
+            'spatial_embeddings': spatial_embeddings,
+            'temporal_embeddings': temporal_embeddings,
+            'cluster_labels': cluster_labels,
+            'stress_scores': stress_scores,
+            'anomaly_labels': anomaly_labels,
+            'anomaly_scores': anomaly_scores,
+            'cluster_centers': self.kmeans.cluster_centers_,
+            'n_clusters': n_clusters
+        }
+
+
+def get_stress_category(stress_score: float) -> str:
+    """Convert stress score to category label."""
+    if stress_score < 0.25:
+        return "Low Stress"
+    elif stress_score < 0.5:
+        return "Moderate Stress"
+    elif stress_score < 0.75:
+        return "High Stress"
+    else:
+        return "Severe Stress"
+
+
+def find_optimal_clusters(embeddings: np.ndarray, 
+                         min_clusters: int = 2, 
+                         max_clusters: int = 10) -> Tuple[int, Dict]:
+    """
+    Find optimal number of clusters using elbow method and silhouette score.
+    
+    Args:
+        embeddings: Array of shape (num_samples, embedding_dim)
+        min_clusters: Minimum number of clusters to test
+        max_clusters: Maximum number of clusters to test
+        
+    Returns:
+        optimal_k: Optimal number of clusters
+        metrics: Dictionary with inertia and silhouette scores
+    """
+    print("\nFinding optimal number of clusters...")
+    
+    scaler = StandardScaler()
+    embeddings_scaled = scaler.fit_transform(embeddings)
+    
+    inertias = []
+    silhouette_scores = []
+    k_range = range(min_clusters, max_clusters + 1)
+    
+    for k in k_range:
+        kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
+        labels = kmeans.fit_predict(embeddings_scaled)
+        
+        inertias.append(kmeans.inertia_)
+        
+        # Calculate silhouette score (higher is better)
+        if k > 1:
+            sil_score = silhouette_score(embeddings_scaled, labels)
+            silhouette_scores.append(sil_score)
+        else:
+            silhouette_scores.append(0)
+        
+        print(f"  k={k}: Inertia={kmeans.inertia_:.2f}, Silhouette={silhouette_scores[-1]:.3f}")
+    
+    # Find elbow using rate of change
+    inertia_diffs = np.diff(inertias)
+    inertia_diffs_2 = np.diff(inertia_diffs)
+    
+    # Optimal k is where second derivative is maximum (elbow point)
+    elbow_k = min_clusters + np.argmax(np.abs(inertia_diffs_2)) + 1
+    
+    # Also consider silhouette score
+    best_silhouette_k = min_clusters + np.argmax(silhouette_scores)
+    
+    # Use silhouette score as primary metric, elbow as secondary
+    optimal_k = best_silhouette_k
+    
+    print(f"\n[OK] Optimal clusters: {optimal_k} (Elbow: {elbow_k}, Best Silhouette: {best_silhouette_k})")
+    
+    metrics = {
+        'k_range': list(k_range),
+        'inertias': inertias,
+        'silhouette_scores': silhouette_scores,
+        'optimal_k': optimal_k,
+        'elbow_k': elbow_k,
+        'best_silhouette_k': best_silhouette_k
+    }
+    
+    return optimal_k, metrics
+
+
+def prepare_llm_context(results: Dict, 
+                       patch_coords: List,
+                       patches: np.ndarray,
+                       metadata: Dict) -> Dict:
+    """
+    Prepare comprehensive context for LLM including cluster statistics and anomaly information.
+    
+    Args:
+        results: Dictionary from model.predict()
+        patch_coords: List of (h, w) coordinates for each patch
+        patches: Original patches array
+        metadata: Preprocessing metadata
+        
+    Returns:
+        context: Dictionary with cluster-wise and anomaly statistics
+    """
+    cluster_labels = results['cluster_labels']
+    stress_scores = results['stress_scores']
+    anomaly_labels = results['anomaly_labels']
+    temporal_embeddings = results['temporal_embeddings']
+    
+    # Get anomaly scores (distance from decision boundary)
+    anomaly_scores = results.get('anomaly_scores', 
+                                 results['anomaly_labels'].astype(float))
+    
+    # Cluster-wise statistics
+    cluster_stats = []
+    for cluster_id in range(results['n_clusters']):
+        cluster_mask = cluster_labels == cluster_id
+        cluster_patches = patches[cluster_mask]
+        cluster_stress = stress_scores[cluster_mask]
+        cluster_embeddings = temporal_embeddings[cluster_mask]
+        
+        # Calculate statistics for this cluster
+        stats = {
+            'cluster_id': int(cluster_id),
+            'num_patches': int(np.sum(cluster_mask)),
+            'percentage': float(100 * np.sum(cluster_mask) / len(cluster_labels)),
+            'stress_score': {
+                'mean': float(cluster_stress.mean()),
+                'std': float(cluster_stress.std()),
+                'min': float(cluster_stress.min()),
+                'max': float(cluster_stress.max())
+            },
+            'embedding_stats': {
+                'mean_norm': float(np.linalg.norm(cluster_embeddings.mean(axis=0))),
+                'std_norm': float(np.linalg.norm(cluster_embeddings.std(axis=0)))
+            },
+            'band_statistics': {}
+        }
+        
+        # Calculate per-band statistics for this cluster
+        for band_idx, band_name in enumerate(metadata['selected_bands']):
+            band_data = cluster_patches[:, :, :, :, band_idx]  # (patches, time, h, w)
+            stats['band_statistics'][band_name] = {
+                'mean': float(np.nanmean(band_data)),
+                'std': float(np.nanstd(band_data)),
+                'min': float(np.nanmin(band_data)),
+                'max': float(np.nanmax(band_data))
+            }
+        
+        cluster_stats.append(stats)
+        
+        # Calculate temporal trends for this cluster
+        # Shape: (num_patches, time, h, w, bands) -> (time, bands)
+        if cluster_patches.shape[0] > 0:
+            cluster_time_series = np.nanmean(cluster_patches, axis=(0, 2, 3))
+            
+            stats['temporal_trends'] = {}
+            for band_idx, band_name in enumerate(metadata['selected_bands']):
+                series = cluster_time_series[:, band_idx]
+                if len(series) > 1:
+                    change = float(series[-1] - series[0])
+                    trend_direction = "stable"
+                    if change > 0.05: trend_direction = "increasing"
+                    elif change < -0.05: trend_direction = "decreasing"
+                    
+                    stats['temporal_trends'][band_name] = {
+                        'change': change,
+                        'trend_direction': trend_direction,
+                        'latest_value': float(series[-1]),
+                        'earliest_value': float(series[0])
+                    }
+    
+    # Anomaly information
+    anomaly_mask = anomaly_labels == -1
+    anomaly_indices = np.where(anomaly_mask)[0]
+    
+    anomaly_info = {
+        'total_anomalies': int(np.sum(anomaly_mask)),
+        'anomaly_percentage': float(100 * np.sum(anomaly_mask) / len(anomaly_labels)),
+        'anomaly_patches': []
+    }
+    
+    # Detailed info for each anomaly patch
+    for idx in anomaly_indices[:20]:  # Limit to first 20 anomalies
+        patch_info = {
+            'patch_id': int(idx),
+            'coordinates': patch_coords[idx],
+            'stress_score': float(stress_scores[idx]),
+            'stress_category': get_stress_category(stress_scores[idx]),
+            'cluster_id': int(cluster_labels[idx]),
+            'anomaly_score': float(anomaly_scores[idx]) if hasattr(anomaly_scores, '__getitem__') else -1.0,
+            'embedding_norm': float(np.linalg.norm(temporal_embeddings[idx]))
+        }
+        anomaly_info['anomaly_patches'].append(patch_info)
+    
+    # Overall field statistics
+    field_stats = {
+        'total_patches': len(cluster_labels),
+        'patch_size': metadata['patch_size'],
+        'num_bands': metadata['num_bands'],
+        'selected_bands': metadata['selected_bands'],
+        'overall_stress': {
+            'mean': float(stress_scores.mean()),
+            'std': float(stress_scores.std()),
+            'min': float(stress_scores.min()),
+            'max': float(stress_scores.max())
+        },
+        'stress_distribution': {
+            'low': int(np.sum(stress_scores < 0.25)),
+            'moderate': int(np.sum((stress_scores >= 0.25) & (stress_scores < 0.5))),
+            'high': int(np.sum((stress_scores >= 0.5) & (stress_scores < 0.75))),
+            'severe': int(np.sum(stress_scores >= 0.75))
+        }
+    }
+    
+    context = {
+        'field_statistics': field_stats,
+        'cluster_statistics': cluster_stats,
+        'anomaly_information': anomaly_info
+    }
+    
+    return context
+

stress_detection_preprocessing.py

@@ -0,0 +1,203 @@
+"""
+Stress Detection Preprocessing Module
+======================================
+
+Prepares Sentinel-2 multi-spectral data for stress detection model.
+Includes band harmonization and normalization.
+"""
+
+import numpy as np
+from typing import Tuple, List
+
+# Band indices in the 12-band Sentinel-2 data
+BAND_INDICES = {
+    'B02': 1,   # Blue
+    'B03': 2,   # Green
+    'B04': 3,   # Red
+    'B05': 4,   # Red Edge 1
+    'B08': 7,   # NIR
+    'B8A': 8,   # NIR Narrow
+    'B11': 10,  # SWIR1
+    'B12': 11   # SWIR2
+}
+
+# Selected bands for stress detection (8 major bands)
+SELECTED_BANDS = ['B02', 'B03', 'B04', 'B05', 'B08', 'B8A', 'B11', 'B12']
+
+
+def extract_major_bands(all_images: np.ndarray) -> np.ndarray:
+    """
+    Extract 8 major bands from 12-band Sentinel-2 data.
+    
+    Args:
+        all_images: Array of shape (time, height, width, 12)
+        
+    Returns:
+        Array of shape (time, height, width, 8) with selected bands
+    """
+    band_idx = [BAND_INDICES[band] for band in SELECTED_BANDS]
+    return all_images[:, :, :, band_idx]
+
+
+def harmonize_bands(images: np.ndarray) -> np.ndarray:
+    """
+    Harmonize band data to same scale [0, 1].
+    
+    Sentinel-2 reflectance values are already in [0, 1] range after DN/10000 conversion.
+    This function ensures all bands are properly normalized and handles any outliers.
+    
+    Args:
+        images: Array of shape (time, height, width, bands)
+        
+    Returns:
+        Harmonized array with values clipped to [0, 1]
+    """
+    # Clip to [0, 1] range to handle any outliers
+    harmonized = np.clip(images, 0, 1)
+    
+    # Additional per-band normalization to ensure uniform scale
+    # Use percentile-based normalization to handle outliers
+    time, height, width, bands = harmonized.shape
+    
+    for b in range(bands):
+        band_data = harmonized[:, :, :, b]
+        
+        # Calculate 2nd and 98th percentiles to handle outliers
+        p2 = np.nanpercentile(band_data, 2)
+        p98 = np.nanpercentile(band_data, 98)
+        
+        # Normalize to [0, 1] using percentiles
+        if p98 > p2:
+            harmonized[:, :, :, b] = np.clip((band_data - p2) / (p98 - p2), 0, 1)
+    
+    return harmonized
+
+
+def handle_nan_values(images: np.ndarray, method='mean') -> np.ndarray:
+    """
+    Handle NaN values in the data.
+    
+    Args:
+        images: Array of shape (time, height, width, bands)
+        method: 'mean', 'zero', or 'interpolate'
+        
+    Returns:
+        Array with NaN values handled
+    """
+    if method == 'zero':
+        return np.nan_to_num(images, nan=0.0)
+    elif method == 'mean':
+        # Replace NaN with temporal mean for each pixel
+        return np.where(np.isnan(images), 
+                       np.nanmean(images, axis=0, keepdims=True), 
+                       images)
+    elif method == 'interpolate':
+        # Simple linear interpolation along time axis
+        result = images.copy()
+        time, height, width, bands = images.shape
+        
+        for h in range(height):
+            for w in range(width):
+                for b in range(bands):
+                    pixel_series = result[:, h, w, b]
+                    if np.any(np.isnan(pixel_series)):
+                        # Interpolate NaN values
+                        mask = ~np.isnan(pixel_series)
+                        if np.any(mask):
+                            indices = np.arange(time)
+                            result[:, h, w, b] = np.interp(
+                                indices, indices[mask], pixel_series[mask]
+                            )
+                        else:
+                            result[:, h, w, b] = 0.0
+        return result
+    else:
+        return images
+
+
+def create_patches(images: np.ndarray, patch_size: int = 4, stride: int = 2) -> Tuple[np.ndarray, List]:
+    """
+    Create overlapping patches from images for spatial analysis.
+    
+    Args:
+        images: Array of shape (time, height, width, bands)
+        patch_size: Size of each patch
+        stride: Stride for patch extraction
+        
+    Returns:
+        patches: Array of shape (num_patches, time, patch_size, patch_size, bands)
+        patch_coords: List of (h_start, w_start) coordinates for each patch
+    """
+    time, height, width, bands = images.shape
+    patches = []
+    patch_coords = []
+    
+    for h in range(0, height - patch_size + 1, stride):
+        for w in range(0, width - patch_size + 1, stride):
+            patch = images[:, h:h+patch_size, w:w+patch_size, :]
+            
+            # Only include patches with sufficient valid data
+            valid_ratio = np.sum(~np.isnan(patch)) / patch.size
+            if valid_ratio > 0.5:  # At least 50% valid data
+                patches.append(patch)
+                patch_coords.append((h, w))
+    
+    if len(patches) == 0:
+        # If no valid patches, create at least one from center
+        h_center = (height - patch_size) // 2
+        w_center = (width - patch_size) // 2
+        patch = images[:, h_center:h_center+patch_size, w_center:w_center+patch_size, :]
+        patches.append(patch)
+        patch_coords.append((h_center, w_center))
+    
+    return np.array(patches), patch_coords
+
+
+def preprocess_for_model(all_images: np.ndarray, 
+                         patch_size: int = 4,
+                         stride: int = 2) -> Tuple[np.ndarray, List, dict]:
+    """
+    Complete preprocessing pipeline for stress detection model.
+    
+    Args:
+        all_images: Raw images of shape (time, height, width, 12)
+        patch_size: Size of patches for spatial analysis
+        stride: Stride for patch extraction
+        
+    Returns:
+        patches: Preprocessed patches ready for model
+        patch_coords: Coordinates of each patch
+        metadata: Dictionary with preprocessing information
+    """
+    print("Preprocessing data for stress detection model...")
+    
+    # Step 1: Extract major bands
+    print("  [1/4] Extracting 8 major bands...")
+    major_bands = extract_major_bands(all_images)
+    
+    # Step 2: Harmonize bands to same scale
+    print("  [2/4] Harmonizing bands to [0, 1] scale...")
+    harmonized = harmonize_bands(major_bands)
+    
+    # Step 3: Handle NaN values
+    print("  [3/4] Handling NaN values...")
+    clean_data = handle_nan_values(harmonized, method='mean')
+    
+    # Step 4: Create patches
+    print("  [4/4] Creating spatial patches...")
+    patches, patch_coords = create_patches(clean_data, patch_size, stride)
+    
+    metadata = {
+        'original_shape': all_images.shape,
+        'selected_bands': SELECTED_BANDS,
+        'num_bands': len(SELECTED_BANDS),
+        'patch_size': patch_size,
+        'stride': stride,
+        'num_patches': len(patches),
+        'harmonized': True
+    }
+    
+    print(f"[OK] Preprocessing complete. Created {len(patches)} patches.")
+    print(f"     Patch shape: {patches.shape}")
+    
+    return patches, patch_coords, metadata

vegetation_indices.py

@@ -113,6 +113,13 @@ def calculate_sfi(img: np.ndarray) -> np.ndarray:
     sasi = calculate_sasi(img)
     return (ndvi * somi) / (sasi + 1e-10)
 
+def calculate_gndvi(img: np.ndarray) -> np.ndarray:
+    """GNDVI (Green NDVI) = (NIR - GREEN) / (NIR + GREEN)
+    Highly sensitive to chlorophyll content and nitrogen status"""
+    nir = img[:, :, 7]   # B08
+    green = img[:, :, 2]  # B03
+    return (nir - green) / (nir + green + 1e-10)
+
 # Index registry
 INDEX_FUNCTIONS = {
     'NDVI': calculate_ndvi,
@@ -127,7 +134,8 @@ INDEX_FUNCTIONS = {
     'MCARI': calculate_mcari,
     'SASI': calculate_sasi,
     'SOMI': calculate_somi,
-    'SFI': calculate_sfi
+    'SFI': calculate_sfi,
+    'GNDVI': calculate_gndvi
 }
 
 # ==================== BATCH CALCULATION ====================