recitfied visualization

backend/app/api/animation.py

@@ -1,14 +1,15 @@
 from fastapi import APIRouter
+
 from app.schemas.common import ApiResponse
-from app.schemas.animation import AnimationSequenceResponse
+
+# from app.schemas.animation import AnimationSequenceResponse
 
 router = APIRouter()
 
+
 @router.get("/{file_id}/sequence", response_model=ApiResponse)
-async def get_sequence(file_id: str, start_time: str = "", end_time: str = "", fps: int = 10):
+async def get_sequence(
+    file_id: str, start_time: str = "", end_time: str = "", fps: int = 10
+):
     # Placeholder
-    return ApiResponse(
-        success=True,
-        message="Animation sequence retrieved",
-        data=None
-    )
+    return ApiResponse(success=True, message="Animation sequence retrieved", data=None)

backend/app/api/visualization.py

@@ -1,12 +1,11 @@
 from fastapi import APIRouter, HTTPException, Query
-from fastapi.responses import FileResponse  # 🚨 NAYA IMPORT
+from fastapi.responses import StreamingResponse
 
 from app.schemas.common import ApiResponse
 from app.services.scientific.visualization_service import VisualizationService
 
 router = APIRouter()
 
-
 @router.get("/{file_id}/variables", response_model=ApiResponse)
 async def get_variables(file_id: str):
     """
@@ -25,40 +24,45 @@ async def get_variables(file_id: str):
         )
 
 
-@router.get("/{file_id}/frame", response_model=ApiResponse)
-async def get_frame(
-    file_id: str,
-    variable: str = Query(..., description="The variable to extract"),
-    time_index: int = Query(0, description="The time index to extract"),
+@router.get("/{file_id}/bounds", response_model=ApiResponse)
+async def get_map_bounds(
+    file_id: str, 
+    variable: str = Query("C13", description="The variable to extract bounds for")
 ):
     """
-    Extract a 2D frame matrix for a specific variable and time index.
+    Get the geographical bounding box coordinates for Leaflet Map.
     """
     try:
-        frame_data = VisualizationService.get_frame(file_id, variable, time_index)
+        bounds_data = VisualizationService.get_map_bounds(file_id, variable)
         return ApiResponse(
             success=True,
-            message=f"Frame data for {variable} extracted successfully.",
-            data=frame_data.model_dump(),
+            message="Map bounds extracted successfully.",
+            data=bounds_data,
         )
     except Exception as e:
         return ApiResponse(
-            success=False, message=f"Failed to extract frame: {str(e)}", data=None
+            success=False, message=f"Failed to extract bounds: {str(e)}", data=None
         )
 
 
-# 🚨 RESPONSE MODEL HATA DIYA HAI AUR FILE RESPONSE BHEJ RAHE HAIN
-@router.get("/{file_id}/thumbnail")
-async def get_thumbnail(
-    file_id: str, variable: str = Query("C13", description="The variable to preview")
+@router.get("/{file_id}/layer")
+async def get_map_layer(
+    file_id: str, 
+    variable: str = Query("C13", description="The variable to extract")
 ):
     """
-    Generate and return a JPEG thumbnail image for the dataset preview.
+    Returns a fast, transparent PNG image overlay for Leaflet Map.
+    Frontend Leaflet will use this URL directly in L.imageOverlay().
     """
     try:
-        thumb_path = VisualizationService.get_thumbnail_path(file_id, variable)
-        return FileResponse(path=thumb_path, media_type="image/jpeg")
-    except Exception as e:
-        return ApiResponse(
-            success=False, message=f"Failed to generate thumbnail: {str(e)}", data=None
+        img_buffer = VisualizationService.get_map_layer_image(file_id, variable)
+        return StreamingResponse(
+            img_buffer, 
+            media_type="image/png",
+            headers={
+                "Cache-Control": "public, max-age=86400",
+                "Content-Disposition": f"inline; filename={file_id}_{variable}.png"
+            } 
         )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/app/schemas/animation.py

@@ -1,7 +1,7 @@
-from pydantic import BaseModel
-from typing import List
-from .visualization import FrameDataResponse
-
-class AnimationSequenceResponse(BaseModel):
-    frames: List[FrameDataResponse]
-    total_frames: int
+# from pydantic import BaseModel
+# from typing import List
+# from .visualization import FrameDataResponse
+#
+# class AnimationSequenceResponse(BaseModel):
+#     frames: List[FrameDataResponse]
+#     total_frames: int

backend/app/schemas/visualization.py

@@ -1,5 +1,7 @@
+from typing import List
+
 from pydantic import BaseModel, Field
-from typing import List, Optional
+
 
 class VariableMetadata(BaseModel):
     name: str = Field(..., description="Name of the scientific variable")
@@ -9,8 +11,8 @@ class VariableMetadata(BaseModel):
     class Config:
         json_schema_extra = {
             "example": {
-                "name": "brightness_temperature",
-                "shape": [24, 512, 512],
+                "name": "C13",
+                "shape": [512, 512],
                 "datatype": "float32"
             }
         }
@@ -23,54 +25,20 @@ class VariablesResponse(BaseModel):
             "example": {
                 "variables": [
                     {
-                        "name": "brightness_temperature",
-                        "shape": [24, 512, 512],
+                        "name": "C13",
+                        "shape": [512, 512],
                         "datatype": "float32"
                     }
                 ]
             }
         }
 
-class FrameStatistics(BaseModel):
-    min: float = Field(..., description="Minimum value in the frame")
-    max: float = Field(..., description="Maximum value in the frame")
-    mean: float = Field(..., description="Mean value of the frame")
-    std: float = Field(..., description="Standard deviation of the frame")
+class MapBoundsResponse(BaseModel):
+    bounds: List[List[float]] = Field(..., description="Geographical bounds for Leaflet map overlay [[South, West], [North, East]]")
 
     class Config:
         json_schema_extra = {
             "example": {
-                "min": 180.3,
-                "max": 321.7,
-                "mean": 245.2,
-                "std": 18.4
-            }
-        }
-
-class FrameDataResponse(BaseModel):
-    file_id: str = Field(..., description="ID of the dataset file")
-    variable: str = Field(..., description="Name of the variable")
-    time_index: int = Field(..., description="Time index of the extracted frame")
-    timestamp: Optional[str] = Field(None, description="ISO timestamp if available")
-    shape: List[int] = Field(..., description="Shape of the 2D frame (height, width)")
-    min: float = Field(..., description="Minimum value in the frame")
-    max: float = Field(..., description="Maximum value in the frame")
-    mean: float = Field(..., description="Mean value of the frame")
-    std: float = Field(..., description="Standard deviation of the frame")
-    z: List[List[float]] = Field(..., description="2D matrix of frame values")
-
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "file_id": "abc123",
-                "variable": "brightness_temperature",
-                "time_index": 5,
-                "timestamp": "2024-01-01T00:15:00Z",
-                "shape": [512, 512],
-                "min": 180.3,
-                "max": 321.7,
-                "mean": 245.2,
-                "std": 18.4,
-                "z": [[240.1, 241.5], [239.8, 240.2]]
+                "bounds": [[8.0, 68.0], [37.0, 97.0]]
             }
         }

backend/app/services/scientific/visualization_service.py

@@ -1,17 +1,16 @@
+import io
 import logging
-import os
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Dict, List
 
-import matplotlib.pyplot as plt
 import numpy as np
 from fastapi import HTTPException
 from huggingface_hub import HfFileSystem
+from PIL import Image
 
-# 🚨 UPLOAD_DIR is completely removed. Using HF configs and Temp Storage.
+# UPLOAD_DIR is replaced with HF configs and Temp Storage.
 from app.core.config import HF_BUCKET_ID, HF_TOKEN, TEMP_STORAGE_DIR
-from app.schemas.visualization import (FrameDataResponse, FrameStatistics,
-                                       VariableMetadata, VariablesResponse)
+from app.schemas.visualization import VariableMetadata, VariablesResponse
 from app.services.scientific.metadata_service import MetadataService
 
 logger = logging.getLogger(__name__)
@@ -19,7 +18,6 @@ logger = logging.getLogger(__name__)
 # Initialize the Hugging Face File System globally for this service
 fs = HfFileSystem(token=HF_TOKEN)
 
-
 class VisualizationService:
 
     @staticmethod
@@ -96,130 +94,94 @@ class VisualizationService:
             raise HTTPException(status_code=400, detail="Invalid Variable")
 
     @staticmethod
-    def validate_time_index(time_index: int):
-        if time_index < 0:
-            logger.error(f"Invalid time index requested: {time_index}")
-            raise HTTPException(status_code=400, detail="Invalid Time Index")
-
-    @staticmethod
-    def compute_statistics(frame: np.ndarray) -> FrameStatistics:
-        valid_data = frame[~np.isnan(frame)]
-        if valid_data.size == 0:
-            return FrameStatistics(min=0.0, max=0.0, mean=0.0, std=0.0)
-
-        return FrameStatistics(
-            min=float(np.min(valid_data)),
-            max=float(np.max(valid_data)),
-            mean=float(np.mean(valid_data)),
-            std=float(np.std(valid_data)),
-        )
-
-    @staticmethod
-    def get_frame(file_id: str, variable: str, time_index: int) -> FrameDataResponse:
+    def get_map_bounds(file_id: str, variable: str) -> Dict[str, List[float]]:
+        """
+        Extracts the geographical bounding box of the satellite data.
+        Returns format for Leaflet: [[South, West], [North, East]]
+        """
         file_path = VisualizationService._get_file_path(file_id)
-        logger.info(f"Dataset opened: {file_id}")
-
         parser = None
         try:
             parser = MetadataService.get_parser(file_path)
             parser.load_dataset(file_path)
-
             VisualizationService.validate_variable(parser, variable)
-            VisualizationService.validate_time_index(time_index)
-
-            try:
-                frame = parser.extract_time_slice(variable, time_index)
-                logger.info("Frame extracted successfully")
-            except Exception as e:
-                logger.error(f"Time slice extraction failed: {str(e)}")
-                raise HTTPException(status_code=400, detail="Invalid Time Index")
-
-            if len(frame.shape) != 2:
-                raise HTTPException(
-                    status_code=400, detail="Frame is not 2D after slicing"
-                )
-
-            timestamp = parser.extract_timestamp(time_index)
-            stats = VisualizationService.compute_statistics(frame)
-
-            frame_small = frame[::10, ::10]
-
-            frame_clean = np.where(
-                np.isnan(frame_small) | np.isinf(frame_small), -9999.0, frame_small
-            ).tolist()
 
-            response = FrameDataResponse(
-                file_id=file_id,
-                variable=variable,
-                time_index=time_index,
-                timestamp=timestamp,
-                shape=list(frame_small.shape),
-                min=stats.min,
-                max=stats.max,
-                mean=stats.mean,
-                std=stats.std,
-                z=frame_clean,
-            )
+            # SatPy scene area se bounds nikalna
+            area = parser.scene[variable].attrs.get('area')
+            if not area:
+                # Default bounds for India/Subcontinent as fallback
+                return {"bounds": [[8.0, 68.0], [37.0, 97.0]]}
+            
+            lons, lats = area.get_lonlats()
+            south, north = float(np.nanmin(lats)), float(np.nanmax(lats))
+            west, east = float(np.nanmin(lons)), float(np.nanmax(lons))
+            
+            return {
+                "bounds": [[south, west], [north, east]]
+            }
 
-            logger.info("Visualization request completed")
-            return response
-
-        except HTTPException:
-            raise
         except Exception as e:
-            logger.error(f"Visualization request failed: {str(e)}")
-            raise HTTPException(status_code=500, detail="Dataset Read Failure")
+            logger.error(f"Failed to extract bounds: {str(e)}")
+            # Fallback bounds if projection logic fails initially
+            return {"bounds": [[8.0, 68.0], [37.0, 97.0]]}
         finally:
             if parser is not None:
                 parser.close()
 
     @staticmethod
-    def get_thumbnail_path(file_id: str, variable: str) -> str:
+    def get_map_layer_image(file_id: str, variable: str) -> io.BytesIO:
         """
-        File se data nikal kar JPEG image banata hai, aur serverless cache me path return karta hai.
+        Converts the 2D scientific array into a transparent PNG for Map Overlay.
+        Replaces both get_frame and get_thumbnail_path to be faster.
         """
-        # 🚨 Cache logic updated for Serverless TEMP_STORAGE_DIR
-        target_dir = Path(TEMP_STORAGE_DIR) / file_id
-        target_dir.mkdir(parents=True, exist_ok=True)
-
-        thumb_path = target_dir / f"thumb_{variable}.jpg"
-
-        # Agar thumbnail pehle se bani hui hai (Cache), toh seedha path do
-        if thumb_path.exists():
-            return str(thumb_path)
-
-        # File path fetch karo (Yeh check karega ki file locally cached hai ya HF se lani hai)
         file_path = VisualizationService._get_file_path(file_id)
-
         parser = None
         try:
             parser = MetadataService.get_parser(file_path)
             parser.load_dataset(file_path)
             VisualizationService.validate_variable(parser, variable)
-
-            # Data nikalo
+            
+            # Extract 2D array matrix (Time index 0)
             frame = parser.extract_time_slice(variable, 0)
 
-            # Downsample for Speed (fast processing)
-            frame_small = frame[::5, ::5]
-
-            # Image banao aur serverless disk cache par save karo
-            plt.figure(figsize=(8, 8))
-            plt.imshow(frame_small, cmap="gray", vmin=90, vmax=313)
-            plt.axis("off")
-
-            plt.savefig(
-                thumb_path, bbox_inches="tight", pad_inches=0, format="jpg", dpi=100
-            )
-            plt.close()
-
-            return str(thumb_path)
-
+            # Downsample optimization for extremely fast web renders
+            frame = frame[::2, ::2]
+
+            # 1. Identify valid data vs empty space/NaNs
+            valid_mask = ~np.isnan(frame) & ~np.isinf(frame)
+            frame_clean = np.where(valid_mask, frame, 90.0)
+
+            # 2. Normalize Brightness Temperature to 0-255 range
+            MIN_BT = 90.0
+            MAX_BT = 313.0
+            frame_norm = np.clip((frame_clean - MIN_BT) / (MAX_BT - MIN_BT) * 255, 0, 255).astype(np.uint8)
+
+            # 3. Create RGBA image matrix (A stands for Alpha/Transparency)
+            rgba_img = np.zeros((frame_norm.shape[0], frame_norm.shape[1], 4), dtype=np.uint8)
+            
+            # Grayscale mapping
+            rgba_img[..., 0] = frame_norm  # Red
+            rgba_img[..., 1] = frame_norm  # Green
+            rgba_img[..., 2] = frame_norm  # Blue
+            
+            # 4. Make NaNs and empty space completely transparent (0 opacity)
+            rgba_img[..., 3] = np.where(valid_mask, 255, 0) 
+
+            # 5. Convert array to PIL Image
+            img = Image.fromarray(rgba_img, mode="RGBA")
+
+            # 6. Save to in-memory byte buffer
+            img_byte_arr = io.BytesIO()
+            img.save(img_byte_arr, format='PNG', optimize=True)
+            img_byte_arr.seek(0)
+
+            return img_byte_arr
+            
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Thumbnail generation failed: {str(e)}")
-            raise HTTPException(status_code=500, detail="Failed to generate thumbnail")
+            logger.error(f"Image layer generation failed: {str(e)}")
+            raise HTTPException(status_code=500, detail="Failed to generate map layer")
         finally:
             if parser is not None:
                 parser.close()

backend/pyproject.toml

@@ -18,7 +18,8 @@ dependencies = [
     "satpy>=0.60.0",
     "scikit-image>=0.26.0",
     "uvicorn>=0.49.0",
-    "scikit-image"
+    "scikit-image",
+    "pillow>=12.2.0",
 ]
 [tool.pyright]
 venvPath = "~/Projects/satellite_video_feed/"

uv.lock

@@ -72,6 +72,7 @@ dependencies = [
     { name = "matplotlib" },
     { name = "netcdf4" },
     { name = "onnxruntime" },
+    { name = "pillow" },
     { name = "python-multipart" },
     { name = "satpy" },
     { name = "scikit-image" },
@@ -89,8 +90,10 @@ requires-dist = [
     { name = "matplotlib", specifier = ">=3.11.0" },
     { name = "netcdf4", specifier = ">=1.7.4" },
     { name = "onnxruntime", specifier = ">=1.27.0" },
+    { name = "pillow", specifier = ">=12.2.0" },
     { name = "python-multipart", specifier = ">=0.0.32" },
     { name = "satpy", specifier = ">=0.60.0" },
+    { name = "scikit-image" },
     { name = "scikit-image", specifier = ">=0.26.0" },
     { name = "uvicorn", specifier = ">=0.49.0" },
 ]