v2.3.0: Pixel-wise + 100-200 patch analysis

- Pixel-wise vegetation index calculation (NOT CNN)
- Target 100-200 patches (10x10 to 15x15 grid)
- Enhanced logging with visual health distribution bars
- Step-by-step progress logging
- Returns 50 patches in response with health categories
- No hardcoded min image size

app.py

@@ -1,29 +1,27 @@
 """
 AGROW Heatmap Service
 =====================
-Generates heatmap images from Sentinel-2 satellite data using the same
-vegetation indices from the main Sentinel-2 pipeline.
+Generates heatmap images from Sentinel-2 satellite data using pixel-wise
+vegetation indices with patch-based statistics.
 
-Version: 2.1.0 - Enhanced logging for debugging
+Version: 2.3.0 - Pixel-wise + 100-200 patch analysis
 """
 
 import os
 import io
-import re
 import base64
 import logging
 import traceback
 from datetime import datetime, timedelta
-from typing import Optional
+from typing import Optional, List
 
 import numpy as np
 from scipy.ndimage import gaussian_filter
 
 import matplotlib
-matplotlib.use('Agg')  # Non-interactive backend
+matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 from matplotlib.colors import LinearSegmentedColormap
-from PIL import Image
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import Response
@@ -34,34 +32,47 @@ from sentinelhub import (
     MimeType, bbox_to_dimensions
 )
 
-# Import vegetation indices from S2 pipeline
-from vegetation_indices import INDEX_FUNCTIONS, calculate_all_indices
+from vegetation_indices import INDEX_FUNCTIONS
 
-# Configure detailed logging
+# ============================================================================
+# LOGGING CONFIGURATION
+# ============================================================================
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S'
+    format='[%(asctime)s] %(levelname)s: %(message)s',
+    datefmt='%H:%M:%S'
 )
-logger = logging.getLogger(__name__)
-
-# Startup logging
-logger.info("=" * 60)
-logger.info("AGROW Heatmap Service - Starting Up")
-logger.info("=" * 60)
-logger.info(f"Available indices: {list(INDEX_FUNCTIONS.keys())}")
-logger.info(f"SH_CLIENT_ID configured: {'Yes' if os.environ.get('SH_CLIENT_ID') else 'No'}")
-logger.info(f"SH_CLIENT_SECRET configured: {'Yes' if os.environ.get('SH_CLIENT_SECRET') else 'No'}")
-logger.info("=" * 60)
-
-# Initialize FastAPI
+logger = logging.getLogger("HeatmapService")
+
+def log_section(title: str):
+    logger.info("=" * 50)
+    logger.info(f"  {title}")
+    logger.info("=" * 50)
+
+def log_step(step_num: int, total: int, msg: str):
+    logger.info(f"[Step {step_num}/{total}] {msg}")
+
+def log_detail(key: str, value):
+    logger.info(f"    • {key}: {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")
+
+# ============================================================================
+# FASTAPI SETUP
+# ============================================================================
 app = FastAPI(
     title="AGROW Heatmap Service",
-    description="Generate heatmap images from Sentinel-2 vegetation indices",
-    version="2.1.0"
+    description="Pixel-wise vegetation indices with 100-200 patch analysis",
+    version="2.3.0"
 )
 
-# CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -70,29 +81,28 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-
-# Sentinel Hub configuration
+# ============================================================================
+# SENTINEL HUB CONFIG
+# ============================================================================
 def get_sh_config():
-    logger.info("  [Config] Loading Sentinel Hub configuration...")
     config = SHConfig()
     config.sh_client_id = os.environ.get('SH_CLIENT_ID', '')
     config.sh_client_secret = os.environ.get('SH_CLIENT_SECRET', '')
     config.sh_base_url = 'https://sh.dataspace.copernicus.eu'
     config.sh_token_url = 'https://identity.dataspace.copernicus.eu/auth/realms/CDSE/protocol/openid-connect/token'
-    
-    logger.info(f"  [Config] Client ID: {config.sh_client_id[:10]}..." if config.sh_client_id else "  [Config] Client ID: NOT SET")
-    logger.info(f"  [Config] Base URL: {config.sh_base_url}")
     return config
 
-
-# Request models
+# ============================================================================
+# REQUEST/RESPONSE MODELS
+# ============================================================================
 class HeatmapRequest(BaseModel):
     center_lat: float
     center_lon: float
-    field_size_hectares: float = 10.0
+    field_size_hectares: float
     index_type: str = "NDVI"
     gaussian_sigma: float = 1.5
     show_field_boundary: bool = True
+    target_patches: int = 150  # Target 100-200 patches
 
 
 class HeatmapResponse(BaseModel):
@@ -101,35 +111,47 @@ class HeatmapResponse(BaseModel):
     min_value: float
     max_value: float
     mean_value: float
+    std_value: float
     image_base64: str
     timestamp: str
     image_date: Optional[str] = None
-
-
-# Custom colormap for vegetation indices
+    image_size: Optional[str] = None
+    num_patches: int
+    patch_grid: Optional[str] = None
+    patches: Optional[List[dict]] = None
+    health_summary: Optional[dict] = None
+
+# ============================================================================
+# COLORMAPS
+# ============================================================================
 def get_vegetation_colormap():
-    colors = [
-        (0.8, 0.2, 0.2),   # Red (stress/low)
-        (0.9, 0.6, 0.2),   # Orange
-        (0.95, 0.9, 0.3),  # Yellow (moderate)
-        (0.6, 0.8, 0.3),   # Light green
-        (0.2, 0.6, 0.2),   # Dark green (healthy/high)
-    ]
+    colors = [(0.8, 0.2, 0.2), (0.9, 0.6, 0.2), (0.95, 0.9, 0.3), (0.6, 0.8, 0.3), (0.2, 0.6, 0.2)]
     return LinearSegmentedColormap.from_list('vegetation', colors, N=256)
 
-
 def get_water_colormap():
-    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)
-    ]
+    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'
 
-# Evalscript to fetch all 13 bands
+# ============================================================================
+# EVALSCRIPT
+# ============================================================================
 FULL_BANDS_EVALSCRIPT = """
 //VERSION=3
 function setup() {
@@ -138,362 +160,296 @@ function setup() {
             bands: ["B01", "B02", "B03", "B04", "B05", "B06", "B07", "B08", "B8A", "B09", "B11", "B12", "dataMask"],
             units: "REFLECTANCE"
         }],
-        output: {
-            bands: 13,
-            sampleType: "FLOAT32"
-        }
+        output: { bands: 13, sampleType: "FLOAT32" }
     };
 }
-
 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
-    ];
+    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 analyze_patches(data: np.ndarray, index_type: str) -> dict:
-    """Analyze data in 4x4 patches for detailed logging."""
+# ============================================================================
+# PATCH ANALYSIS (100-200 patches)
+# ============================================================================
+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.
+    """
     h, w = data.shape
-    patch_h, patch_w = h // 4, w // 4
     
-    patches = []
-    for i in range(4):
-        for j in range(4):
-            patch = data[i*patch_h:(i+1)*patch_h, j*patch_w:(j+1)*patch_w]
+    # 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)
+    
+    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)
+            
+            patch = data[y_start:y_end, x_start:x_end]
             valid_pixels = np.sum(~np.isnan(patch))
+            
             if valid_pixels > 0:
-                patches.append({
-                    'row': i, 'col': j,
-                    'min': float(np.nanmin(patch)),
-                    'max': float(np.nanmax(patch)),
-                    'mean': float(np.nanmean(patch)),
-                    'std': float(np.nanstd(patch)),
-                    'valid_pixels': int(valid_pixels)
+                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)
                 })
+                
+                health_counts[health] = health_counts.get(health, 0) + 1
     
-    return {
-        'total_patches': len(patches),
-        'patches': patches
+    total = len(patches_list)
+    health_summary = {
+        '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 {}
     }
-
-
-def generate_heatmap_image(
-    data: np.ndarray, 
-    index_type: str,
-    gaussian_sigma: float = 1.5,
-    show_field_boundary: bool = True
-) -> tuple:
-    """Generate a heatmap image from index data with optional smoothing and field boundary."""
     
-    logger.info("  [Heatmap] Starting image generation...")
+    # 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."""
     
-    # Handle NaN values
     valid_mask = ~np.isnan(data)
-    valid_count = np.sum(valid_mask)
-    total_pixels = data.size
-    logger.info(f"  [Heatmap] Valid pixels: {valid_count}/{total_pixels} ({100*valid_count/total_pixels:.1f}%)")
+    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 found")
+        raise ValueError("No valid data pixels")
     
     min_val = float(np.nanmin(data))
     max_val = float(np.nanmax(data))
     mean_val = float(np.nanmean(data))
     std_val = float(np.nanstd(data))
     
-    logger.info(f"  [Heatmap] {index_type} Statistics:")
-    logger.info(f"    - Min: {min_val:.4f}")
-    logger.info(f"    - Max: {max_val:.4f}")
-    logger.info(f"    - Mean: {mean_val:.4f}")
-    logger.info(f"    - Std: {std_val:.4f}")
+    logger.info(f"    • {index_type} Stats: min={min_val:.4f}, max={max_val:.4f}, mean={mean_val:.4f}, std={std_val:.4f}")
     
-    # Normalize data to 0-1 range for colormap
-    data_normalized = np.clip((data - min_val) / (max_val - min_val + 1e-8), 0, 1)
-    data_normalized = np.nan_to_num(data_normalized, nan=0.5)
+    # 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)
     
-    # Apply Gaussian smoothing if sigma > 0
+    # Gaussian smoothing
     if gaussian_sigma > 0:
-        logger.info(f"  [Heatmap] Applying Gaussian smoothing (sigma={gaussian_sigma})...")
-        data_normalized = gaussian_filter(data_normalized, sigma=gaussian_sigma)
-    else:
-        logger.info("  [Heatmap] Skipping Gaussian smoothing (sigma=0)")
+        logger.info(f"    • Applying Gaussian smoothing (σ={gaussian_sigma})")
+        data_norm = gaussian_filter(data_norm, sigma=gaussian_sigma)
     
     # Create figure
-    logger.info("  [Heatmap] Creating matplotlib figure...")
     fig, ax = plt.subplots(figsize=(8, 8), dpi=100)
+    cmap = get_water_colormap() if index_type in ['NDWI', 'SMI'] else get_vegetation_colormap()
+    im = ax.imshow(data_norm, cmap=cmap, interpolation='bilinear')
     
-    # Select colormap based on index type
-    if index_type in ['NDWI', 'SMI']:
-        cmap = get_water_colormap()
-        logger.info(f"  [Heatmap] Using water colormap for {index_type}")
-    else:
-        cmap = get_vegetation_colormap()
-        logger.info(f"  [Heatmap] Using vegetation colormap for {index_type}")
-    
-    im = ax.imshow(data_normalized, cmap=cmap, interpolation='bilinear')
-    
-    # Draw field boundary if enabled
-    if show_field_boundary:
-        logger.info("  [Heatmap] Drawing field boundary overlay...")
-        h, w = data_normalized.shape
-        padding = 0.05
-        rect = plt.Rectangle(
-            (w * padding, h * padding),
-            w * (1 - 2 * padding),
-            h * (1 - 2 * padding),
-            fill=False,
-            edgecolor='white',
-            linewidth=2,
-            linestyle='--',
-            alpha=0.6
-        )
+    # 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, 
+                              edgecolor='white', linewidth=2, linestyle='--', alpha=0.7)
         ax.add_patch(rect)
-        
-        corners = [
-            (w * padding, h * padding),
-            (w * (1 - padding), h * padding),
-            (w * padding, h * (1 - padding)),
-            (w * (1 - padding), h * (1 - padding))
-        ]
-        for cx, cy in corners:
-            ax.plot(cx, cy, 'o', color='white', markersize=6, alpha=0.7)
-    else:
-        logger.info("  [Heatmap] Skipping field boundary overlay")
     
-    # Add colorbar
+    # Colorbar
     cbar = plt.colorbar(im, ax=ax, shrink=0.8, pad=0.02)
-    cbar.set_label(f'{index_type} Value', fontsize=10)
-    
-    cbar_ticks = np.linspace(0, 1, 5)
-    cbar_labels = [f'{min_val + t * (max_val - min_val):.2f}' for t in cbar_ticks]
-    cbar.set_ticks(cbar_ticks)
-    cbar.set_ticklabels(cbar_labels)
+    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])
     
     ax.set_title(f'{index_type} Heatmap', fontsize=14, fontweight='bold')
     ax.axis('off')
     
-    # Save to buffer
-    logger.info("  [Heatmap] Saving to PNG buffer...")
     buf = io.BytesIO()
-    plt.savefig(buf, format='png', bbox_inches='tight', facecolor='white', edgecolor='none')
+    plt.savefig(buf, format='png', bbox_inches='tight', facecolor='white')
     plt.close(fig)
     buf.seek(0)
     
-    img_base64 = base64.b64encode(buf.getvalue()).decode('utf-8')
-    logger.info(f"  [Heatmap] Generated image: {len(img_base64)} bytes (base64)")
+    img_b64 = base64.b64encode(buf.getvalue()).decode('utf-8')
+    logger.info(f"    • Image generated: {len(img_b64):,} bytes (base64)")
     
-    return img_base64, min_val, max_val, mean_val
-
+    return img_b64, min_val, max_val, mean_val, std_val
 
+# ============================================================================
+# API ENDPOINTS
+# ============================================================================
 @app.get("/")
 async def root():
-    logger.info("Root endpoint accessed")
     return {
         "service": "AGROW Heatmap Service",
-        "version": "2.1.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"
-        }
+        "version": "2.3.0",
+        "mode": "Pixel-wise + 100-200 patch analysis",
+        "indices": list(INDEX_FUNCTIONS.keys())
     }
 
-
 @app.get("/health")
 async def health():
-    logger.info("Health check requested")
-    return {"status": "healthy", "indices_available": list(INDEX_FUNCTIONS.keys())}
+    return {"status": "healthy"}
 
 
 @app.post("/generate-heatmap", response_model=HeatmapResponse)
 async def generate_heatmap(request: HeatmapRequest):
-    """Generate a heatmap image for the specified location and index type."""
+    """Generate heatmap with pixel-wise index calculation and patch analysis."""
     
-    request_id = datetime.now().strftime("%H%M%S%f")[:10]
+    req_id = datetime.now().strftime("%H%M%S")
     
-    logger.info("=" * 60)
-    logger.info(f"[{request_id}] NEW HEATMAP REQUEST")
-    logger.info("=" * 60)
-    logger.info(f"[{request_id}] Parameters:")
-    logger.info(f"  - Center: ({request.center_lat}, {request.center_lon})")
-    logger.info(f"  - Field Size: {request.field_size_hectares} hectares")
-    logger.info(f"  - Index Type: {request.index_type}")
-    logger.info(f"  - Gaussian Sigma: {request.gaussian_sigma}")
-    logger.info(f"  - Show Boundary: {request.show_field_boundary}")
+    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 index type
     if request.index_type not in INDEX_FUNCTIONS:
-        logger.error(f"[{request_id}] Invalid index type: {request.index_type}")
-        raise HTTPException(
-            status_code=400, 
-            detail=f"Invalid index type '{request.index_type}'. Supported: {list(INDEX_FUNCTIONS.keys())}"
-        )
+        raise HTTPException(400, f"Invalid index: {request.index_type}")
     
     try:
-        # Step 1: Configure Sentinel Hub
-        logger.info(f"[{request_id}] Step 1/5: Configuring Sentinel Hub...")
+        # STEP 1: Config
+        log_step(1, 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: Calculate bounding box
-        logger.info(f"[{request_id}] Step 2/5: Calculating bounding box...")
-        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)))
+        # STEP 2: Bounding Box
+        log_step(2, 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)))
         
-        bbox_coords = (
-            request.center_lon - lon_offset,
-            request.center_lat - lat_offset,
-            request.center_lon + lon_offset,
-            request.center_lat + lat_offset
-        )
-        bbox = BBox(bbox_coords, crs=CRS.WGS84)
-        
-        logger.info(f"  [BBox] SW: ({bbox_coords[1]:.6f}, {bbox_coords[0]:.6f})")
-        logger.info(f"  [BBox] NE: ({bbox_coords[3]:.6f}, {bbox_coords[2]:.6f})")
+        bbox = BBox((
+            request.center_lon - lon_off, request.center_lat - lat_off,
+            request.center_lon + lon_off, request.center_lat + lat_off
+        ), crs=CRS.WGS84)
         
-        # Calculate resolution
         size = bbox_to_dimensions(bbox, resolution=10)
-        size = (max(size[0], 64), max(size[1], 64))
-        logger.info(f"  [BBox] Image size: {size[0]}x{size[1]} pixels at 10m resolution")
+        log_detail("Image Size", f"{size[0]}×{size[1]} pixels @ 10m")
+        log_detail("Coverage", f"{size[0]*10}m × {size[1]*10}m")
         
-        # Step 3: Prepare Sentinel Hub request
-        logger.info(f"[{request_id}] Step 3/5: Preparing Sentinel Hub request...")
+        # STEP 3: Fetch Data
+        log_step(3, 5, "Fetching Sentinel-2 data")
         end_date = datetime.now()
         start_date = end_date - timedelta(days=30)
-        logger.info(f"  [Time] Date range: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
+        log_detail("Date Range", f"{start_date.strftime('%Y-%m-%d')} → {end_date.strftime('%Y-%m-%d')}")
         
-        SENTINEL2_L2A_CDSE = DataCollection.define(
-            "SENTINEL2_L2A_CDSE",
-            api_id="sentinel-2-l2a",
+        SENTINEL2 = DataCollection.define(
+            "S2_CDSE", api_id="sentinel-2-l2a",
             service_url="https://sh.dataspace.copernicus.eu",
-            collection_type="Sentinel-2",
-            is_timeless=False
+            collection_type="Sentinel-2", is_timeless=False
         )
         
         sh_request = SentinelHubRequest(
             evalscript=FULL_BANDS_EVALSCRIPT,
-            input_data=[
-                SentinelHubRequest.input_data(
-                    data_collection=SENTINEL2_L2A_CDSE,
-                    time_interval=(start_date.strftime('%Y-%m-%d'), end_date.strftime('%Y-%m-%d')),
-                    mosaicking_order='leastCC'
-                )
-            ],
+            input_data=[SentinelHubRequest.input_data(
+                data_collection=SENTINEL2,
+                time_interval=(start_date.strftime('%Y-%m-%d'), end_date.strftime('%Y-%m-%d')),
+                mosaicking_order='leastCC'
+            )],
             responses=[SentinelHubRequest.output_response('default', MimeType.TIFF)],
-            bbox=bbox,
-            size=size,
-            config=config
+            bbox=bbox, size=size, config=config
         )
         
-        # Step 4: Fetch satellite data
-        logger.info(f"[{request_id}] Step 4/5: Fetching satellite data from Sentinel Hub...")
         data = sh_request.get_data()[0]
         
         if data is None or data.size == 0:
-            logger.error(f"[{request_id}] No satellite data returned!")
-            raise HTTPException(status_code=404, detail="No satellite data available for this location")
-        
-        logger.info(f"  [Data] Data shape: {data.shape}")
-        logger.info(f"  [Data] Data type: {data.dtype}")
-        logger.info(f"  [Data] Data range: [{np.nanmin(data):.4f}, {np.nanmax(data):.4f}]")
+            raise HTTPException(404, "No satellite data available")
         
-        # Band statistics
-        band_names = ['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09', 'B11', 'B12', 'dataMask']
-        logger.info("  [Bands] Band statistics:")
-        for i, name in enumerate(band_names[:12]):
-            band = data[:, :, i]
-            logger.info(f"    {name}: min={np.nanmin(band):.4f}, max={np.nanmax(band):.4f}, mean={np.nanmean(band):.4f}")
-        
-        # Step 5: Calculate vegetation index
-        logger.info(f"[{request_id}] Step 5/5: Calculating {request.index_type} index...")
-        img_data = data[:, :, :12]  # Remove dataMask
+        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)")
+        img_data = data[:, :, :12]
         index_func = INDEX_FUNCTIONS[request.index_type]
         index_data = index_func(img_data)
         
-        logger.info(f"  [Index] {request.index_type} calculated:")
-        logger.info(f"    - Shape: {index_data.shape}")
-        logger.info(f"    - Min: {np.nanmin(index_data):.4f}")
-        logger.info(f"    - Max: {np.nanmax(index_data):.4f}")
-        logger.info(f"    - Mean: {np.nanmean(index_data):.4f}")
+        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}")
         
-        # Patch analysis
-        logger.info(f"  [Patches] Analyzing 4x4 patch grid...")
-        patch_info = analyze_patches(index_data, request.index_type)
-        for p in patch_info['patches'][:4]:  # Show first 4 patches
-            logger.info(f"    Patch[{p['row']},{p['col']}]: mean={p['mean']:.4f}, std={p['std']:.4f}")
-        if len(patch_info['patches']) > 4:
-            logger.info(f"    ... and {len(patch_info['patches']) - 4} more patches")
+        # 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)
         
-        # Generate heatmap
-        logger.info(f"[{request_id}] Generating heatmap image...")
-        img_base64, min_val, max_val, mean_val = generate_heatmap_image(
-            index_data, 
-            request.index_type,
-            gaussian_sigma=request.gaussian_sigma,
-            show_field_boundary=request.show_field_boundary
+        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
         )
         
-        logger.info(f"[{request_id}] SUCCESS - Heatmap generated!")
-        logger.info("=" * 60)
+        log_section(f"SUCCESS [{req_id}]")
+        logger.info(f"  Generated {request.index_type} heatmap with {len(patches_list)} patches")
         
         return HeatmapResponse(
             success=True,
             index_type=request.index_type,
-            min_value=min_val,
-            max_value=max_val,
-            mean_value=mean_val,
-            image_base64=img_base64,
+            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_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
         )
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"[{request_id}] FAILED - Error generating heatmap:")
-        logger.error(f"  Error: {str(e)}")
-        logger.error(f"  Traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"[{req_id}] ERROR: {str(e)}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(500, str(e))
 
 
 @app.get("/generate-heatmap-image")
-async def generate_heatmap_image_direct(
-    center_lat: float,
-    center_lon: float,
-    field_size_hectares: float = 10.0,
-    index_type: str = "NDVI",
-    gaussian_sigma: float = 1.5,
-    show_field_boundary: bool = True
+async def get_heatmap_image(
+    center_lat: float, center_lon: float, field_size_hectares: float,
+    index_type: str = "NDVI", gaussian_sigma: float = 1.5
 ):
-    """Generate and return heatmap as PNG image directly."""
-    
-    logger.info(f"Direct image request: {index_type} at ({center_lat}, {center_lon})")
-    
     request = HeatmapRequest(
-        center_lat=center_lat,
-        center_lon=center_lon,
-        field_size_hectares=field_size_hectares,
-        index_type=index_type,
-        gaussian_sigma=gaussian_sigma,
-        show_field_boundary=show_field_boundary
+        center_lat=center_lat, center_lon=center_lon,
+        field_size_hectares=field_size_hectares, index_type=index_type,
+        gaussian_sigma=gaussian_sigma
     )
-    
     response = await generate_heatmap(request)
-    
-    img_bytes = base64.b64decode(response.image_base64)
-    
-    return Response(content=img_bytes, media_type="image/png")
+    return Response(content=base64.b64decode(response.image_base64), media_type="image/png")
 
 
 if __name__ == "__main__":
     import uvicorn
-    logger.info("Starting Uvicorn server on port 7860...")
     uvicorn.run(app, host="0.0.0.0", port=7860)