Update app.py

app.py

@@ -1,1157 +1,1157 @@
-import cv2
-import torch
-import numpy as np
-from collections import deque
-from threading import Thread, Lock
-from queue import Queue
-import time
-import logging
-import os
-from datetime import datetime
-from PIL import Image
-from transformers import SegformerForSemanticSegmentation, SegformerImageProcessor
-from fastapi import FastAPI, HTTPException, StreamingResponse
-from fastapi.responses import FileResponse, StreamingResponse
-import asyncio
-import uvicorn
-from pydantic import BaseModel
-from typing import Optional
-import requests
-from datetime import datetime, timedelta
-
-# ===== IMPORT THE DISCORD ALERT MANAGER =====
-from send_discord import DiscordAlertManager
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# ==================== DATA MODELS ====================
-
-class StreamStartRequest(BaseModel):
-    """Start streaming request."""
-    rtmp_input_url: str
-    camera_path: str  # e.g., "models/cam1" - will auto-pick gmm_model.joblib and mask.png
-
-
-class StreamStopRequest(BaseModel):
-    """Stop streaming request."""
-    stream_id: str
-
-
-class StreamStatusResponse(BaseModel):
-    """Stream status response."""
-    stream_id: str
-    status: str
-    fps: float
-    buffered_frames: int
-    queue_size: int
-
-
-# ==================== CIRCULAR BUFFER ====================
-
-class CircularFrameBuffer:
-    """Fixed-size buffer for storing processed frames."""
-    
-    def __init__(self, max_frames: int = 30):
-        self.max_frames = max_frames
-        self.frames = deque(maxlen=max_frames)
-        self.lock = Lock()
-        self.sequence_ids = deque(maxlen=max_frames)
-    
-    def add_frame(self, frame: np.ndarray, seq_id: int) -> None:
-        """Add processed frame to buffer."""
-        with self.lock:
-            self.frames.append(frame.copy())
-            self.sequence_ids.append(seq_id)
-    
-    def get_latest(self) -> tuple:
-        """Get most recent frame."""
-        with self.lock:
-            if len(self.frames) > 0:
-                return self.frames[-1].copy(), self.sequence_ids[-1]
-            return None, None
-    
-    def clear(self) -> None:
-        """Clear buffer."""
-        with self.lock:
-            self.frames.clear()
-            self.sequence_ids.clear()
-
-
-# ==================== LIVE MONITOR ====================
-
-class LiveHygieneMonitor:
-    """Production-ready hygiene monitor for live streams."""
-    
-    def __init__(self, segformer_path: str, max_buffer_frames: int = 30):
-        self.segformer_path = segformer_path
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        
-        # Model loading
-        self.model = None
-        self.processor = None
-        self._load_segformer()
-        
-        # GMM components
-        self.gmm_model = None
-        self.gmm_heatmap = None
-        self.table_mask = None
-        
-        # Live streaming state
-        self.frame_buffer = CircularFrameBuffer(max_frames=max_buffer_frames)
-        self.input_queue = Queue(maxsize=5)
-        self.processing_thread = None
-        self.is_running = False
-        
-        # Frame sequence tracking
-        self.frame_sequence = 0
-        self.frame_lock = Lock()
-        
-        # State management
-        self.detection_frames_count = 0
-        self.no_detection_frames_count = 0
-        self.cleaning_active = False
-        self.cleaning_start_threshold = 4
-        self.cleaning_stop_threshold = 12
-        
-        # Performance tracking
-        self.frame_times = deque(maxlen=30)
-        self.last_frame_time = time.time()
-        
-        # Optimization flags
-        self.skip_segformer_every_n_frames = 2
-        self.segformer_skip_counter = 0
-        self.last_cloth_mask = None
-        
-        # Visualization settings
-        self.show_cloth_detection = True
-        self.erasure_radius_factor = 0.2
-        self.gaussian_sigma_factor = 0.8
-        
-        self.tracker = None
-        self.track_trajectories = {}
-        self.max_trajectory_length = 40
-        self.track_colors = {}
-        
-        # Alert manager - ADD THIS
-        self.alert_manager = None
-        self.current_camera_name = "Default Camera"
-        
-        logger.info(f"Live Monitor initialized on {self.device}")
-    
-    def _load_segformer(self):
-        """Load SegFormer model."""
-        try:
-            self.model = SegformerForSemanticSegmentation.from_pretrained(self.segformer_path)
-            self.processor = SegformerImageProcessor(do_reduce_labels=False)
-            self.model.to(self.device)
-            self.model.eval()
-            logger.info(f"SegFormer loaded on {self.device}")
-        except Exception as e:
-            logger.error(f"Failed to load SegFormer: {e}")
-    
-    def _init_tracker(self):
-        """Lazy-init tracker."""
-        if self.tracker is None:
-            from deep_sort_realtime.deepsort_tracker import DeepSort
-            self.tracker = DeepSort(
-                max_age=15,
-                n_init=2,
-                nms_max_overlap=0.7,
-                max_cosine_distance=0.4,
-                nn_budget=50,
-                embedder="mobilenet",
-                half=True,
-                embedder_gpu=torch.cuda.is_available()
-            )
-    
-    def load_gmm_model(self, gmm_path: str) -> bool:
-        """Load GMM model."""
-        try:
-            from GMM import GMM
-            self.gmm_model = GMM.load_model(gmm_path)
-            if self.gmm_model.img_shape:
-                h, w = self.gmm_model.img_shape[:2]
-                self.gmm_heatmap = np.zeros((h, w), dtype=np.float32)
-            logger.info("GMM model loaded")
-            return True
-        except Exception as e:
-            logger.error(f"Failed to load GMM: {e}")
-            return False
-    
-    def load_table_mask(self, mask_path: str) -> bool:
-        """Load table mask."""
-        try:
-            mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE)
-            self.table_mask = (mask > 128).astype(np.uint8)
-            logger.info(f"Table mask loaded: {mask.shape}")
-            return True
-        except Exception as e:
-            logger.error(f"Failed to load mask: {e}")
-            return False
-    
-    def add_frame(self, frame: np.ndarray) -> None:
-        """Add incoming frame (non-blocking)."""
-        try:
-            self.input_queue.put_nowait(frame)
-        except:
-            pass
-    
-    def start_processing(self) -> None:
-        """Start background processing."""
-        if self.is_running:
-            return
-        self.is_running = True
-        self.processing_thread = Thread(target=self._process_loop, daemon=True)
-        self.processing_thread.start()
-        logger.info("Processing thread started")
-    
-    def stop_processing(self) -> None:
-        """Stop processing."""
-        self.is_running = False
-        if self.processing_thread:
-            self.processing_thread.join(timeout=5)
-        self.frame_buffer.clear()
-        logger.info("Processing stopped")
-    
-    def _get_next_sequence_id(self) -> int:
-        """Thread-safe sequence ID."""
-        with self.frame_lock:
-            self.frame_sequence += 1
-            return self.frame_sequence
-    
-    def _process_loop(self) -> None:
-        """Main processing loop."""
-        while self.is_running:
-            try:
-                frame = self.input_queue.get(timeout=1)
-                seq_id = self._get_next_sequence_id()
-                
-                frame = self._resize_frame(frame, target_width=1024)
-                cloth_mask = self._detect_cloth_fast(frame)
-                cleaning_status = self._update_cleaning_status(cloth_mask)
-                
-                tracks = None
-                if self.cleaning_active:
-                    self._init_tracker()
-                    tracks = self._track_cloth(frame, cloth_mask)
-                
-                self._update_gmm_fast(frame, cloth_mask, tracks)
-                viz_frame = self._create_visualization(frame, cloth_mask, tracks, cleaning_status)
-                self.frame_buffer.add_frame(viz_frame, seq_id)
-                
-                elapsed = time.time() - self.last_frame_time
-                self.frame_times.append(elapsed)
-                self.last_frame_time = time.time()
-                
-                if seq_id % 30 == 0:
-                    avg_time = np.mean(self.frame_times)
-                    fps = 1.0 / avg_time if avg_time > 0 else 0
-                    logger.info(f"Seq {seq_id} | {fps:.1f} FPS | {cleaning_status}")
-            
-            except Exception as e:
-                logger.error(f"Processing error: {e}")
-                continue
-    
-    def _resize_frame(self, frame: np.ndarray, target_width: int = 1024) -> np.ndarray:
-        """Resize frame."""
-        h, w = frame.shape[:2]
-        if w > target_width:
-            scale = target_width / w
-            new_h = int(h * scale)
-            return cv2.resize(frame, (target_width, new_h))
-        return frame
-    
-    def _detect_cloth_fast(self, frame: np.ndarray) -> np.ndarray:
-        """Fast cloth detection with skipping."""
-        if self.model is None:
-            return np.zeros((frame.shape[0], frame.shape[1]), dtype=np.uint8)
-        
-        self.segformer_skip_counter += 1
-        if self.segformer_skip_counter < self.skip_segformer_every_n_frames:
-            if self.last_cloth_mask is not None:
-                return self.last_cloth_mask
-            return np.zeros((frame.shape[0], frame.shape[1]), dtype=np.uint8)
-        
-        self.segformer_skip_counter = 0
-        
-        try:
-            height, width = frame.shape[:2]
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            pil_image = Image.fromarray(frame_rgb)
-            
-            with torch.no_grad():
-                inputs = self.processor(images=pil_image, return_tensors="pt")
-                inputs = {k: v.to(self.device) for k, v in inputs.items()}
-                outputs = self.model(**inputs)
-                logits = outputs.logits
-            
-            upsampled = torch.nn.functional.interpolate(
-                logits, size=(height, width), mode="bilinear", align_corners=False
-            )
-            
-            cloth_mask = (upsampled.argmax(dim=1)[0].cpu().numpy() == 1).astype(np.uint8)
-            
-            if self.table_mask is not None:
-                if self.table_mask.shape != cloth_mask.shape:
-                    table_resized = cv2.resize(self.table_mask, (width, height))
-                else:
-                    table_resized = self.table_mask
-                cloth_mask = cloth_mask * table_resized
-            
-            self.last_cloth_mask = cloth_mask
-            return cloth_mask
-        
-        except Exception as e:
-            logger.error(f"Cloth detection error: {e}")
-            return np.zeros((frame.shape[0], frame.shape[1]), dtype=np.uint8)
-    
-    def _track_cloth(self, frame: np.ndarray, cloth_mask: np.ndarray) -> list:
-        """Fast tracking."""
-        if self.tracker is None:
-            return []
-        
-        try:
-            contours, _ = cv2.findContours(cloth_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-            detections = []
-            
-            for contour in contours:
-                area = cv2.contourArea(contour)
-                if area < 150:
-                    continue
-                x, y, w, h = cv2.boundingRect(contour)
-                if w > 0 and h > 0:
-                    detections.append(([x, y, w, h], 0.95, 'cloth'))
-            
-            if not detections:
-                return []
-            
-            tracks = self.tracker.update_tracks(detections, frame=frame)
-            
-            height, width = frame.shape[:2]
-            for track in tracks:
-                if not track.is_confirmed():
-                    continue
-                
-                track_id = track.track_id
-                bbox = track.to_ltrb()
-                cx = int((bbox[0] + bbox[2]) / 2)
-                cy = int((bbox[1] + bbox[3]) / 2)
-                
-                if 0 <= cx < width and 0 <= cy < height:
-                    if track_id not in self.track_trajectories:
-                        self.track_trajectories[track_id] = deque(maxlen=self.max_trajectory_length)
-                        self.track_colors[track_id] = (255, 255, 0)
-                    self.track_trajectories[track_id].append((cx, cy))
-            
-            active_ids = {track.track_id for track in tracks if track.is_confirmed()}
-            dead_ids = set(self.track_trajectories.keys()) - active_ids
-            for dead_id in dead_ids:
-                self.track_trajectories.pop(dead_id, None)
-                self.track_colors.pop(dead_id, None)
-            
-            return tracks
-        
-        except Exception as e:
-            logger.error(f"Tracking error: {e}")
-            return []
-    
-    def _update_gmm_fast(self, frame: np.ndarray, cloth_mask: np.ndarray, tracks: list) -> None:
-        """Lightweight GMM update."""
-        if self.gmm_model is None:
-            return
-        
-        try:
-            height, width = frame.shape[:2]
-            table_mask = None
-            if self.table_mask is not None:
-                if self.table_mask.shape != (height, width):
-                    table_mask = cv2.resize(self.table_mask, (width, height))
-                else:
-                    table_mask = self.table_mask
-            
-            _, self.gmm_heatmap = self.gmm_model.infer(
-                frame, heatmap=self.gmm_heatmap,
-                alpha_start=0.008, alpha_end=0.0004,
-                table_mask=table_mask
-            )
-            
-            if self.cleaning_active and tracks:
-                for track in tracks:
-                    if not track.is_confirmed():
-                        continue
-                    
-                    track_id = track.track_id
-                    if track_id not in self.track_trajectories:
-                        continue
-                    
-                    trajectory = list(self.track_trajectories[track_id])
-                    if len(trajectory) < 2:
-                        continue
-                    
-                    bbox = track.to_ltrb()
-                    w = bbox[2] - bbox[0]
-                    h = bbox[3] - bbox[1]
-                    
-                    radius = int(min(w, h) * self.erasure_radius_factor)
-                    radius = max(radius, 12)
-                    
-                    if radius <= 0 or w <= 0 or h <= 0:
-                        continue
-                    
-                    for i in range(len(trajectory) - 1):
-                        self._erase_at_point(trajectory[i], radius, table_mask)
-        
-        except Exception as e:
-            logger.error(f"GMM update error: {e}")
-    
-    def _erase_at_point(self, point: tuple, radius: int, table_mask: np.ndarray) -> None:
-        """Fast point-based erasure."""
-        if self.gmm_heatmap is None or radius <= 0:
-            return
-        
-        x, y = point
-        height, width = self.gmm_heatmap.shape
-        
-        y_min = max(0, y - radius)
-        y_max = min(height, y + radius)
-        x_min = max(0, x - radius)
-        x_max = min(width, x + radius)
-        
-        if y_min >= y_max or x_min >= x_max:
-            return
-        
-        y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
-        distance_sq = (x_indices - x)**2 + (y_indices - y)**2
-        
-        gaussian = np.exp(-distance_sq / (2 * (radius * self.gaussian_sigma_factor)**2))
-        
-        if table_mask is not None:
-            gaussian = gaussian * table_mask[y_min:y_max, x_min:x_max]
-        
-        decay = 0.025 * gaussian
-        self.gmm_heatmap[y_min:y_max, x_min:x_max] = np.maximum(
-            0, self.gmm_heatmap[y_min:y_max, x_min:x_max] - decay
-        )
-    
-    def _update_cleaning_status(self, cloth_mask: np.ndarray) -> str:
-        """Update cleaning status."""
-        has_cloth = np.sum(cloth_mask) > 100
-        
-        if has_cloth:
-            self.detection_frames_count += 1
-            self.no_detection_frames_count = 0
-        else:
-            self.no_detection_frames_count += 1
-            self.detection_frames_count = 0
-        
-        if not self.cleaning_active and self.detection_frames_count >= self.cleaning_start_threshold:
-            self.cleaning_active = True
-            return "CLEANING STARTED"
-        elif self.cleaning_active and self.no_detection_frames_count >= self.cleaning_stop_threshold:
-            self.cleaning_active = False
-            return "CLEANING STOPPED"
-        
-        return "CLEANING ACTIVE" if self.cleaning_active else "NO CLEANING"
-    
-    def _create_visualization(self, frame: np.ndarray, cloth_mask: np.ndarray, 
-                            tracks: list, cleaning_status: str) -> np.ndarray:
-        """Create fast visualization."""
-        result = frame.copy()
-        
-        if np.sum(cloth_mask) > 0:
-            overlay = result.copy()
-            cloth_pixels = cloth_mask > 0
-            overlay[cloth_pixels] = [0, 255, 0]
-            result[cloth_pixels] = cv2.addWeighted(
-                frame[cloth_pixels], 0.7, overlay[cloth_pixels], 0.3, 0
-            )
-        
-        if self.gmm_heatmap is not None and self.gmm_heatmap.max() > 0:
-            height, width = result.shape[:2]
-            heatmap_resized = cv2.resize(self.gmm_heatmap, (width, height))
-            heatmap_colored = cv2.applyColorMap(
-                (heatmap_resized * 255).astype(np.uint8), cv2.COLORMAP_JET
-            )
-            significant = heatmap_resized > 0.1
-            result[significant] = cv2.addWeighted(
-                frame[significant], 0.6, heatmap_colored[significant], 0.4, 0
-            )
-        
-        if tracks:
-            for track in tracks:
-                if track.is_confirmed():
-                    bbox = track.to_ltrb()
-                    cx, cy = int((bbox[0] + bbox[2])/2), int((bbox[1] + bbox[3])/2)
-                    cv2.circle(result, (cx, cy), 4, (0, 0, 255), -1)
-        
-        status_color = (0, 255, 0) if "ACTIVE" in cleaning_status else (150, 150, 150)
-        cv2.putText(result, cleaning_status, (20, 40),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, status_color, 2)
-        
-        return result
-    
-    def get_latest_frame(self) -> np.ndarray:
-        """Get latest processed frame."""
-        frame, _ = self.frame_buffer.get_latest()
-        return frame
-    
-    def get_stats(self) -> dict:
-        """Get stats."""
-        with self.frame_buffer.lock:
-            avg_time = np.mean(self.frame_times) if len(self.frame_times) > 0 else 0.033
-            fps = 1.0 / avg_time if avg_time > 0 else 0
-            return {
-                "buffered_frames": len(self.frame_buffer.frames),
-                "avg_fps": fps,
-                "queue_size": self.input_queue.qsize(),
-                "is_running": self.is_running
-            }
-
-
-# ==================== FASTAPI APP ====================
-
-app = FastAPI(title="Hygiene Monitor Live Stream", version="1.0.0")
-
-# Active streams: {stream_id: {"monitor": LiveHygieneMonitor, "cap": VideoCapture, "thread": Thread}}
-active_streams = {}
-streams_lock = Lock()
-
-
-def _get_model_files(camera_path: str) -> tuple:
-    """Extract GMM and mask paths from camera directory."""
-    if not os.path.isdir(camera_path):
-        raise ValueError(f"Camera path not found: {camera_path}")
-    
-    gmm_path = os.path.join(camera_path, "gmm_model.joblib")
-    mask_path = os.path.join(camera_path, "mask.png")
-    
-    if not os.path.exists(gmm_path):
-        raise ValueError(f"GMM model not found: {gmm_path}")
-    if not os.path.exists(mask_path):
-        raise ValueError(f"Mask not found: {mask_path}")
-    
-    return gmm_path, mask_path
-
-
-def _stream_worker(stream_id: str, rtmp_url: str, gmm_path: str, mask_path: str):
-    """Background worker for streaming."""
-    try:
-        monitor = LiveHygieneMonitor(
-            segformer_path="models/segformer_model",
-            max_buffer_frames=30
-        )
-        
-        if not monitor.load_gmm_model(gmm_path):
-            logger.error(f"[{stream_id}] Failed to load GMM model")
-            return
-        
-        if not monitor.load_table_mask(mask_path):
-            logger.error(f"[{stream_id}] Failed to load mask")
-            return
-        
-        # === INITIALIZE ALERT MANAGER - ADD THIS ===
-        webhook_url = os.getenv("DISCORD_WEBHOOK_URL")  # From environment
-        if webhook_url:
-            monitor.alert_manager = DiscordAlertManager(webhook_url=webhook_url)
-            monitor.current_camera_name = stream_id  # Or pass from request
-            logger.info(f"[{stream_id}] Alert manager initialized")
-        
-        monitor.start_processing()
-        
-        cap = cv2.VideoCapture(rtmp_url)
-        if not cap.isOpened():
-            logger.error(f"[{stream_id}] Failed to connect to RTMP: {rtmp_url}")
-            monitor.stop_processing()
-            return
-        
-        # Update active stream
-        with streams_lock:
-            if stream_id in active_streams:
-                active_streams[stream_id]["monitor"] = monitor
-                active_streams[stream_id]["cap"] = cap
-                active_streams[stream_id]["connected"] = True
-        
-        frame_count = 0
-        logger.info(f"[{stream_id}] Connected to {rtmp_url}")
-        
-        while True:
-            with streams_lock:
-                if stream_id not in active_streams or not active_streams[stream_id]["running"]:
-                    break
-            
-            ret, frame = cap.read()
-            if not ret:
-                logger.warning(f"[{stream_id}] RTMP connection lost, reconnecting...")
-                cap.release()
-                time.sleep(2)
-                cap = cv2.VideoCapture(rtmp_url)
-                continue
-            
-            monitor.add_frame(frame)
-            frame_count += 1
-            
-            if frame_count % 100 == 0:
-                stats = monitor.get_stats()
-                logger.info(f"[{stream_id}] Frames: {frame_count}, FPS: {stats['avg_fps']:.1f}")
-    
-    except Exception as e:
-        logger.error(f"[{stream_id}] Stream error: {e}")
-    
-    finally:
-        with streams_lock:
-            if stream_id in active_streams:
-                if active_streams[stream_id]["cap"]:
-                    active_streams[stream_id]["cap"].release()
-                if active_streams[stream_id]["monitor"]:
-                    active_streams[stream_id]["monitor"].stop_processing()
-                active_streams[stream_id]["connected"] = False
-        
-        logger.info(f"[{stream_id}] Stream closed")
-
-
-# ==================== ENDPOINTS ====================
-
-@app.post("/stream/start")
-async def start_stream(request: StreamStartRequest):
-    """Start a new live stream."""
-    stream_id = f"stream_{int(time.time() * 1000)}"
-    
-    try:
-        # Extract model files from camera path
-        gmm_path, mask_path = _get_model_files(request.camera_path)
-        
-        # Create stream entry
-        with streams_lock:
-            active_streams[stream_id] = {
-                "running": True,
-                "connected": False,
-                "monitor": None,
-                "cap": None,
-                "thread": None,
-                "camera_path": request.camera_path
-            }
-        
-        # Start background worker thread
-        thread = Thread(
-            target=_stream_worker,
-            args=(stream_id, request.rtmp_input_url, gmm_path, mask_path),
-            daemon=True
-        )
-        thread.start()
-        
-        with streams_lock:
-            active_streams[stream_id]["thread"] = thread
-        
-        logger.info(f"Stream {stream_id} started")
-        return {
-            "stream_id": stream_id,
-            "status": "starting",
-            "message": f"Stream {stream_id} is starting, will connect to {request.rtmp_input_url}"
-        }
-    
-    except Exception as e:
-        logger.error(f"Failed to start stream: {e}")
-        raise HTTPException(status_code=400, detail=str(e))
-
-
-@app.post("/stream/stop")
-async def stop_stream(request: StreamStopRequest):
-    """Stop a live stream."""
-    stream_id = request.stream_id
-    
-    with streams_lock:
-        if stream_id not in active_streams:
-            raise HTTPException(status_code=404, detail=f"Stream {stream_id} not found")
-        
-        active_streams[stream_id]["running"] = False
-    
-    logger.info(f"Stream {stream_id} stop requested")
-    return {"stream_id": stream_id, "status": "stopping"}
-
-
-@app.get("/stream/status/{stream_id}")
-async def get_stream_status(stream_id: str):
-    """Get stream status."""
-    with streams_lock:
-        if stream_id not in active_streams:
-            raise HTTPException(status_code=404, detail=f"Stream {stream_id} not found")
-        
-        stream_data = active_streams[stream_id]
-        monitor = stream_data["monitor"]
-        
-        stats = monitor.get_stats() if monitor else {}
-        
-        return {
-            "stream_id": stream_id,
-            "connected": stream_data["connected"],
-            "running": stream_data["running"],
-            "camera_path": stream_data["camera_path"],
-            "fps": stats.get("avg_fps", 0),
-            "buffered_frames": stats.get("buffered_frames", 0),
-            "queue_size": stats.get("queue_size", 0)
-        }
-
-
-@app.get("/stream/video/{stream_id}")
-async def stream_video(stream_id: str):
-    """Stream video frames via MJPEG."""
-    with streams_lock:
-        if stream_id not in active_streams:
-            raise HTTPException(status_code=404, detail=f"Stream {stream_id} not found")
-        
-        monitor = active_streams[stream_id]["monitor"]
-    
-    if not monitor:
-        raise HTTPException(status_code=503, detail="Monitor not ready")
-    
-    async def frame_generator():
-        while True:
-            with streams_lock:
-                if stream_id not in active_streams or not active_streams[stream_id]["running"]:
-                    break
-            
-            frame = monitor.get_latest_frame()
-            if frame is not None:
-                _, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 80])
-                yield (b'--frame\r\n'
-                       b'Content-Type: image/jpeg\r\n'
-                       b'Content-Length: ' + str(len(buffer)).encode() + b'\r\n\r\n'
-                       + buffer.tobytes() + b'\r\n')
-            else:
-                await asyncio.sleep(0.01)
-    
-    return StreamingResponse(
-        frame_generator(),
-        media_type="multipart/x-mixed-replace; boundary=frame"
-    )
-
-
-@app.get("/streams")
-async def list_streams():
-    """List all active streams."""
-    with streams_lock:
-        streams_list = []
-        for stream_id, data in active_streams.items():
-            monitor = data["monitor"]
-            stats = monitor.get_stats() if monitor else {}
-            
-            streams_list.append({
-                "stream_id": stream_id,
-                "connected": data["connected"],
-                "running": data["running"],
-                "camera_path": data["camera_path"],
-                "fps": stats.get("avg_fps", 0),
-                "buffered_frames": stats.get("buffered_frames", 0)
-            })
-        
-        return {"total_streams": len(streams_list), "streams": streams_list}
-
-
-@app.post("/stream/restart/{stream_id}")
-async def restart_stream(stream_id: str):
-    """Restart a stream."""
-    with streams_lock:
-        if stream_id not in active_streams:
-            raise HTTPException(status_code=404, detail=f"Stream {stream_id} not found")
-        
-        active_streams[stream_id]["running"] = False
-    
-    await asyncio.sleep(2)
-    
-    with streams_lock:
-        data = active_streams[stream_id]
-        data["running"] = True
-    
-    return {"stream_id": stream_id, "status": "restarting"}
-
-@app.post("/camera/extract_frame")
-async def extract_frame_from_rtmp(request: dict):
-    """
-    Extract a single frame from RTMP stream for corner selection.
-    
-    Request body:
-    {
-        "rtmp_url": "rtmp://192.168.1.100:1935/live/kitchen",
-        "camera_name": "kitchen"
-    }
-    
-    Returns:
-    {
-        "success": true,
-        "frame_base64": "base64_encoded_image",
-        "frame_dimensions": {"width": 1920, "height": 1080}
-    }
-    """
-    try:
-        rtmp_url = request.get("rtmp_url")
-        camera_name = request.get("camera_name")
-        
-        if not rtmp_url or not camera_name:
-            raise HTTPException(status_code=400, detail="Missing rtmp_url or camera_name")
-        
-        # Connect to RTMP stream
-        cap = cv2.VideoCapture(rtmp_url)
-        if not cap.isOpened():
-            raise HTTPException(status_code=400, detail=f"Failed to connect to RTMP: {rtmp_url}")
-        
-        # Read first frame
-        ret, frame = cap.read()
-        cap.release()
-        
-        if not ret:
-            raise HTTPException(status_code=400, detail="Failed to read frame from RTMP stream")
-        import base64
-        # Convert frame to base64 for frontend display
-        _, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 95])
-        frame_base64 = base64.b64encode(buffer).decode('utf-8')
-        
-        # Store frame temporarily for training (optional - could store in memory cache)
-        temp_dir = "temp_frames"
-        os.makedirs(temp_dir, exist_ok=True)
-        temp_frame_path = os.path.join(temp_dir, f"{camera_name}_reference.jpg")
-        cv2.imwrite(temp_frame_path, frame)
-        
-        return {
-            "success": True,
-            "frame_base64": frame_base64,
-            "frame_dimensions": {
-                "width": frame.shape[1],
-                "height": frame.shape[0]
-            },
-            "temp_frame_path": temp_frame_path
-        }
-        
-    except Exception as e:
-        logger.error(f"Extract frame error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/camera/train_gmm")
-async def train_gmm_from_rtmp(request: dict):
-    """
-    Train GMM model from RTMP stream using N corner points (minimum 4).
-    
-    Request body:
-    {
-        "rtmp_url": "rtmp://192.168.1.100:1935/live/kitchen",
-        "camera_name": "kitchen",
-        "corner_points": [
-            {"x": 100, "y": 50},
-            {"x": 400, "y": 45},
-            {"x": 700, "y": 55},
-            {"x": 800, "y": 60},
-            {"x": 850, "y": 300},
-            {"x": 850, "y": 600},
-            {"x": 400, "y": 620},
-            {"x": 50, "y": 580},
-            {"x": 45, "y": 300}
-        ],  // Can be 4+ points for curved tables
-        "max_frames": 250,
-        "use_perspective_warp": false  // NEW: Set false for non-rectangular tables
-    }
-    """
-    try:
-        rtmp_url = request.get("rtmp_url")
-        camera_name = request.get("camera_name")
-        corner_points = request.get("corner_points")
-        max_frames = request.get("max_frames", 250)
-        use_perspective_warp = request.get("use_perspective_warp", False)  # NEW
-        
-        # Validation
-        if not rtmp_url or not camera_name or not corner_points:
-            raise HTTPException(status_code=400, detail="Missing required parameters")
-        
-        if len(corner_points) < 4:
-            raise HTTPException(status_code=400, detail="Minimum 4 corner points required")
-        
-        logger.info(f"Starting GMM training for camera: {camera_name} with {len(corner_points)} points")
-        
-        # ===== STEP 1: Connect to RTMP and capture frames =====
-        cap = cv2.VideoCapture(rtmp_url)
-        if not cap.isOpened():
-            raise HTTPException(status_code=400, detail=f"Failed to connect to RTMP: {rtmp_url}")
-        
-        ret, first_frame = cap.read()
-        if not ret:
-            cap.release()
-            raise HTTPException(status_code=400, detail="Failed to read from RTMP stream")
-        
-        h, w = first_frame.shape[:2]
-        
-        # ===== STEP 2: Create polygon mask from N points =====
-        pts_polygon = np.array([
-            [point['x'], point['y']] for point in corner_points
-        ], dtype=np.int32)
-        
-        # Create binary mask for the table area
-        table_mask = np.zeros((h, w), dtype=np.uint8)
-        cv2.fillPoly(table_mask, [pts_polygon], 255)
-        
-        # ===== STEP 3: Decide transformation strategy =====
-        import tempfile
-        temp_dir = tempfile.mkdtemp()
-        frame_count = 0
-        
-        if use_perspective_warp and len(corner_points) == 4:
-            # ===== STRATEGY A: Perspective warp (rectangular tables only) =====
-            logger.info("Using perspective warp for rectangular table")
-            
-            pts_src = np.array([
-                [corner_points[0]['x'], corner_points[0]['y']],
-                [corner_points[1]['x'], corner_points[1]['y']],
-                [corner_points[2]['x'], corner_points[2]['y']],
-                [corner_points[3]['x'], corner_points[3]['y']]
-            ], dtype=np.float32)
-            
-            pts_dst = np.array([
-                [0, 0], [w, 0], [w, h], [0, h]
-            ], dtype=np.float32)
-            
-            matrix = cv2.getPerspectiveTransform(pts_src, pts_dst)
-            
-            # Capture and warp frames
-            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-            while frame_count < max_frames:
-                ret, frame = cap.read()
-                if not ret:
-                    break
-                
-                warped = cv2.warpPerspective(frame, matrix, (w, h))
-                frame_path = os.path.join(temp_dir, f'b{frame_count:05d}.png')
-                cv2.imwrite(frame_path, warped)
-                frame_count += 1
-                
-                if frame_count % 50 == 0:
-                    logger.info(f"Captured {frame_count}/{max_frames} frames")
-            
-            # For warped images, mask should be full frame (already aligned)
-            final_mask = np.ones((h, w), dtype=np.uint8) * 255
-            
-        else:
-            # ===== STRATEGY B: Direct masking (curved/complex tables) =====
-            logger.info(f"Using direct masking for {len(corner_points)}-point polygon (curved table)")
-            
-            # Capture frames WITHOUT warping, apply mask during inference
-            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-            while frame_count < max_frames:
-                ret, frame = cap.read()
-                if not ret:
-                    break
-                
-                # Apply mask to frame (zero out outside table area)
-                masked_frame = cv2.bitwise_and(frame, frame, mask=table_mask)
-                
-                frame_path = os.path.join(temp_dir, f'b{frame_count:05d}.png')
-                cv2.imwrite(frame_path, masked_frame)
-                frame_count += 1
-                
-                if frame_count % 50 == 0:
-                    logger.info(f"Captured {frame_count}/{max_frames} frames")
-            
-            # Use original polygon mask
-            final_mask = table_mask
-        
-        cap.release()
-        
-        if frame_count == 0:
-            raise HTTPException(status_code=400, detail="No frames captured")
-        
-        logger.info(f"Captured {frame_count} frames, starting GMM training...")
-        
-        # ===== STEP 4: Train GMM =====
-        from GMM import GMM
-        gmm = GMM(temp_dir, frame_count, alpha=0.05)
-        gmm.train(K=4)
-        logger.info("GMM training complete")
-        
-        # ===== STEP 5: Save artifacts =====
-        camera_path = os.path.join("models", camera_name)
-        os.makedirs(camera_path, exist_ok=True)
-        
-        # 1. Save GMM model
-        gmm_path = os.path.join(camera_path, "gmm_model.joblib")
-        gmm.save_model(gmm_path)
-        
-        # 2. Save mask (polygon-based, not rectangular)
-        mask_path = os.path.join(camera_path, "mask.png")
-        cv2.imwrite(mask_path, final_mask)
-        logger.info(f"Saved {len(corner_points)}-point polygon mask to {mask_path}")
-        
-        # 3. Create thumbnail with polygon overlay
-        thumb_frame = first_frame.copy()
-        
-        # Draw filled polygon with transparency
-        overlay = thumb_frame.copy()
-        cv2.fillPoly(overlay, [pts_polygon], (0, 255, 0))
-        cv2.addWeighted(thumb_frame, 0.7, overlay, 0.3, 0, thumb_frame)
-        
-        # Draw polygon border
-        cv2.polylines(thumb_frame, [pts_polygon], True, (0, 255, 0), 3)
-        
-        # Draw corner points with numbers
-        colors = [
-            (255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0),
-            (255, 0, 255), (0, 255, 255), (128, 0, 128), (255, 128, 0)
-        ]
-        
-        for i, point in enumerate(corner_points):
-            x, y = point['x'], point['y']
-            color = colors[i % len(colors)]
-            
-            cv2.circle(thumb_frame, (x, y), 8, color, -1)
-            cv2.circle(thumb_frame, (x, y), 10, (255, 255, 255), 2)
-            
-            # Point number
-            cv2.putText(thumb_frame, str(i+1), (x+15, y), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
-        
-        # Camera name label
-        cv2.putText(thumb_frame, camera_name, (30, 50),
-                   cv2.FONT_HERSHEY_DUPLEX, 1.5, (255, 255, 255), 3)
-        cv2.putText(thumb_frame, camera_name, (30, 50),
-                   cv2.FONT_HERSHEY_DUPLEX, 1.5, (0, 255, 0), 2)
-        
-        # Add point count indicator
-        cv2.putText(thumb_frame, f"{len(corner_points)} points", (30, 90),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)
-        
-        thumb_path = os.path.join(camera_path, "thumb.png")
-        cv2.imwrite(thumb_path, thumb_frame)
-        
-        # 4. Save polygon metadata (NEW - for reconstruction)
-        metadata = {
-            "camera_name": camera_name,
-            "num_points": len(corner_points),
-            "corner_points": corner_points,
-            "frame_dimensions": {"width": w, "height": h},
-            "use_perspective_warp": use_perspective_warp,
-            "training_date": datetime.now().isoformat()
-        }
-        
-        import json
-        metadata_path = os.path.join(camera_path, "metadata.json")
-        with open(metadata_path, 'w') as f:
-            json.dump(metadata, f, indent=2)
-        
-        logger.info(f"Saved metadata to {metadata_path}")
-        
-        # Cleanup
-        import shutil
-        shutil.rmtree(temp_dir)
-        
-        logger.info(f"✅ Camera '{camera_name}' training complete with {len(corner_points)}-point polygon!")
-        
-        return {
-            "success": True,
-            "camera_name": camera_name,
-            "camera_path": camera_path,
-            "frames_captured": frame_count,
-            "polygon_points": len(corner_points),
-            "use_perspective_warp": use_perspective_warp,
-            "model_files": {
-                "gmm_model": gmm_path,
-                "mask": mask_path,
-                "thumbnail": thumb_path,
-                "metadata": metadata_path
-            }
-        }
-        
-    except Exception as e:
-        logger.error(f"GMM training error: {e}")
-        import traceback
-        logger.error(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/cameras")
-async def list_cameras():
-    """
-    List all trained cameras with their metadata.
-    
-    Returns:
-    {
-        "cameras": [
-            {
-                "name": "kitchen",
-                "path": "models/kitchen",
-                "thumbnail": "models/kitchen/thumb.png",
-                "has_gmm_model": true,
-                "has_mask": true
-            }
-        ]
-    }
-    """
-    try:
-        cameras = []
-        models_dir = "models"
-        
-        if not os.path.exists(models_dir):
-            return {"cameras": []}
-        
-        for camera_name in os.listdir(models_dir):
-            camera_path = os.path.join(models_dir, camera_name)
-            
-            if not os.path.isdir(camera_path):
-                continue
-            
-            gmm_path = os.path.join(camera_path, "gmm_model.joblib")
-            mask_path = os.path.join(camera_path, "mask.png")
-            thumb_path = os.path.join(camera_path, "thumb.png")
-            
-            cameras.append({
-                "name": camera_name,
-                "path": camera_path,
-                "thumbnail": thumb_path if os.path.exists(thumb_path) else None,
-                "has_gmm_model": os.path.exists(gmm_path),
-                "has_mask": os.path.exists(mask_path)
-            })
-        
-        return {"cameras": cameras}
-        
-    except Exception as e:
-        logger.error(f"List cameras error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.delete("/camera/{camera_name}")
-async def delete_camera(camera_name: str):
-    """
-    Delete a trained camera and all its files.
-    """
-    try:
-        camera_path = os.path.join("models", camera_name)
-        
-        if not os.path.exists(camera_path):
-            raise HTTPException(status_code=404, detail=f"Camera '{camera_name}' not found")
-        
-        import shutil
-        shutil.rmtree(camera_path)
-        
-        logger.info(f"Deleted camera: {camera_name}")
-        
-        return {
-            "success": True,
-            "message": f"Camera '{camera_name}' deleted successfully"
-        }
-        
-    except Exception as e:
-        logger.error(f"Delete camera error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint."""
-    with streams_lock:
-        stream_count = len(active_streams)
-    
-    return {
-        "status": "healthy",
-        "active_streams": stream_count,
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-if __name__ == "__main__":
+import cv2
+import torch
+import numpy as np
+from collections import deque
+from threading import Thread, Lock
+from queue import Queue
+import time
+import logging
+import os
+from datetime import datetime
+from PIL import Image
+from transformers import SegformerForSemanticSegmentation, SegformerImageProcessor
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse, StreamingResponse
+import asyncio
+import uvicorn
+from pydantic import BaseModel
+from typing import Optional
+import requests
+from datetime import datetime, timedelta
+
+# ===== IMPORT THE DISCORD ALERT MANAGER =====
+from send_discord import DiscordAlertManager
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ==================== DATA MODELS ====================
+
+class StreamStartRequest(BaseModel):
+    """Start streaming request."""
+    rtmp_input_url: str
+    camera_path: str  # e.g., "models/cam1" - will auto-pick gmm_model.joblib and mask.png
+
+
+class StreamStopRequest(BaseModel):
+    """Stop streaming request."""
+    stream_id: str
+
+
+class StreamStatusResponse(BaseModel):
+    """Stream status response."""
+    stream_id: str
+    status: str
+    fps: float
+    buffered_frames: int
+    queue_size: int
+
+
+# ==================== CIRCULAR BUFFER ====================
+
+class CircularFrameBuffer:
+    """Fixed-size buffer for storing processed frames."""
+    
+    def __init__(self, max_frames: int = 30):
+        self.max_frames = max_frames
+        self.frames = deque(maxlen=max_frames)
+        self.lock = Lock()
+        self.sequence_ids = deque(maxlen=max_frames)
+    
+    def add_frame(self, frame: np.ndarray, seq_id: int) -> None:
+        """Add processed frame to buffer."""
+        with self.lock:
+            self.frames.append(frame.copy())
+            self.sequence_ids.append(seq_id)
+    
+    def get_latest(self) -> tuple:
+        """Get most recent frame."""
+        with self.lock:
+            if len(self.frames) > 0:
+                return self.frames[-1].copy(), self.sequence_ids[-1]
+            return None, None
+    
+    def clear(self) -> None:
+        """Clear buffer."""
+        with self.lock:
+            self.frames.clear()
+            self.sequence_ids.clear()
+
+
+# ==================== LIVE MONITOR ====================
+
+class LiveHygieneMonitor:
+    """Production-ready hygiene monitor for live streams."""
+    
+    def __init__(self, segformer_path: str, max_buffer_frames: int = 30):
+        self.segformer_path = segformer_path
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Model loading
+        self.model = None
+        self.processor = None
+        self._load_segformer()
+        
+        # GMM components
+        self.gmm_model = None
+        self.gmm_heatmap = None
+        self.table_mask = None
+        
+        # Live streaming state
+        self.frame_buffer = CircularFrameBuffer(max_frames=max_buffer_frames)
+        self.input_queue = Queue(maxsize=5)
+        self.processing_thread = None
+        self.is_running = False
+        
+        # Frame sequence tracking
+        self.frame_sequence = 0
+        self.frame_lock = Lock()
+        
+        # State management
+        self.detection_frames_count = 0
+        self.no_detection_frames_count = 0
+        self.cleaning_active = False
+        self.cleaning_start_threshold = 4
+        self.cleaning_stop_threshold = 12
+        
+        # Performance tracking
+        self.frame_times = deque(maxlen=30)
+        self.last_frame_time = time.time()
+        
+        # Optimization flags
+        self.skip_segformer_every_n_frames = 2
+        self.segformer_skip_counter = 0
+        self.last_cloth_mask = None
+        
+        # Visualization settings
+        self.show_cloth_detection = True
+        self.erasure_radius_factor = 0.2
+        self.gaussian_sigma_factor = 0.8
+        
+        self.tracker = None
+        self.track_trajectories = {}
+        self.max_trajectory_length = 40
+        self.track_colors = {}
+        
+        # Alert manager - ADD THIS
+        self.alert_manager = None
+        self.current_camera_name = "Default Camera"
+        
+        logger.info(f"Live Monitor initialized on {self.device}")
+    
+    def _load_segformer(self):
+        """Load SegFormer model."""
+        try:
+            self.model = SegformerForSemanticSegmentation.from_pretrained(self.segformer_path)
+            self.processor = SegformerImageProcessor(do_reduce_labels=False)
+            self.model.to(self.device)
+            self.model.eval()
+            logger.info(f"SegFormer loaded on {self.device}")
+        except Exception as e:
+            logger.error(f"Failed to load SegFormer: {e}")
+    
+    def _init_tracker(self):
+        """Lazy-init tracker."""
+        if self.tracker is None:
+            from deep_sort_realtime.deepsort_tracker import DeepSort
+            self.tracker = DeepSort(
+                max_age=15,
+                n_init=2,
+                nms_max_overlap=0.7,
+                max_cosine_distance=0.4,
+                nn_budget=50,
+                embedder="mobilenet",
+                half=True,
+                embedder_gpu=torch.cuda.is_available()
+            )
+    
+    def load_gmm_model(self, gmm_path: str) -> bool:
+        """Load GMM model."""
+        try:
+            from GMM import GMM
+            self.gmm_model = GMM.load_model(gmm_path)
+            if self.gmm_model.img_shape:
+                h, w = self.gmm_model.img_shape[:2]
+                self.gmm_heatmap = np.zeros((h, w), dtype=np.float32)
+            logger.info("GMM model loaded")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load GMM: {e}")
+            return False
+    
+    def load_table_mask(self, mask_path: str) -> bool:
+        """Load table mask."""
+        try:
+            mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE)
+            self.table_mask = (mask > 128).astype(np.uint8)
+            logger.info(f"Table mask loaded: {mask.shape}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load mask: {e}")
+            return False
+    
+    def add_frame(self, frame: np.ndarray) -> None:
+        """Add incoming frame (non-blocking)."""
+        try:
+            self.input_queue.put_nowait(frame)
+        except:
+            pass
+    
+    def start_processing(self) -> None:
+        """Start background processing."""
+        if self.is_running:
+            return
+        self.is_running = True
+        self.processing_thread = Thread(target=self._process_loop, daemon=True)
+        self.processing_thread.start()
+        logger.info("Processing thread started")
+    
+    def stop_processing(self) -> None:
+        """Stop processing."""
+        self.is_running = False
+        if self.processing_thread:
+            self.processing_thread.join(timeout=5)
+        self.frame_buffer.clear()
+        logger.info("Processing stopped")
+    
+    def _get_next_sequence_id(self) -> int:
+        """Thread-safe sequence ID."""
+        with self.frame_lock:
+            self.frame_sequence += 1
+            return self.frame_sequence
+    
+    def _process_loop(self) -> None:
+        """Main processing loop."""
+        while self.is_running:
+            try:
+                frame = self.input_queue.get(timeout=1)
+                seq_id = self._get_next_sequence_id()
+                
+                frame = self._resize_frame(frame, target_width=1024)
+                cloth_mask = self._detect_cloth_fast(frame)
+                cleaning_status = self._update_cleaning_status(cloth_mask)
+                
+                tracks = None
+                if self.cleaning_active:
+                    self._init_tracker()
+                    tracks = self._track_cloth(frame, cloth_mask)
+                
+                self._update_gmm_fast(frame, cloth_mask, tracks)
+                viz_frame = self._create_visualization(frame, cloth_mask, tracks, cleaning_status)
+                self.frame_buffer.add_frame(viz_frame, seq_id)
+                
+                elapsed = time.time() - self.last_frame_time
+                self.frame_times.append(elapsed)
+                self.last_frame_time = time.time()
+                
+                if seq_id % 30 == 0:
+                    avg_time = np.mean(self.frame_times)
+                    fps = 1.0 / avg_time if avg_time > 0 else 0
+                    logger.info(f"Seq {seq_id} | {fps:.1f} FPS | {cleaning_status}")
+            
+            except Exception as e:
+                logger.error(f"Processing error: {e}")
+                continue
+    
+    def _resize_frame(self, frame: np.ndarray, target_width: int = 1024) -> np.ndarray:
+        """Resize frame."""
+        h, w = frame.shape[:2]
+        if w > target_width:
+            scale = target_width / w
+            new_h = int(h * scale)
+            return cv2.resize(frame, (target_width, new_h))
+        return frame
+    
+    def _detect_cloth_fast(self, frame: np.ndarray) -> np.ndarray:
+        """Fast cloth detection with skipping."""
+        if self.model is None:
+            return np.zeros((frame.shape[0], frame.shape[1]), dtype=np.uint8)
+        
+        self.segformer_skip_counter += 1
+        if self.segformer_skip_counter < self.skip_segformer_every_n_frames:
+            if self.last_cloth_mask is not None:
+                return self.last_cloth_mask
+            return np.zeros((frame.shape[0], frame.shape[1]), dtype=np.uint8)
+        
+        self.segformer_skip_counter = 0
+        
+        try:
+            height, width = frame.shape[:2]
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            pil_image = Image.fromarray(frame_rgb)
+            
+            with torch.no_grad():
+                inputs = self.processor(images=pil_image, return_tensors="pt")
+                inputs = {k: v.to(self.device) for k, v in inputs.items()}
+                outputs = self.model(**inputs)
+                logits = outputs.logits
+            
+            upsampled = torch.nn.functional.interpolate(
+                logits, size=(height, width), mode="bilinear", align_corners=False
+            )
+            
+            cloth_mask = (upsampled.argmax(dim=1)[0].cpu().numpy() == 1).astype(np.uint8)
+            
+            if self.table_mask is not None:
+                if self.table_mask.shape != cloth_mask.shape:
+                    table_resized = cv2.resize(self.table_mask, (width, height))
+                else:
+                    table_resized = self.table_mask
+                cloth_mask = cloth_mask * table_resized
+            
+            self.last_cloth_mask = cloth_mask
+            return cloth_mask
+        
+        except Exception as e:
+            logger.error(f"Cloth detection error: {e}")
+            return np.zeros((frame.shape[0], frame.shape[1]), dtype=np.uint8)
+    
+    def _track_cloth(self, frame: np.ndarray, cloth_mask: np.ndarray) -> list:
+        """Fast tracking."""
+        if self.tracker is None:
+            return []
+        
+        try:
+            contours, _ = cv2.findContours(cloth_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            detections = []
+            
+            for contour in contours:
+                area = cv2.contourArea(contour)
+                if area < 150:
+                    continue
+                x, y, w, h = cv2.boundingRect(contour)
+                if w > 0 and h > 0:
+                    detections.append(([x, y, w, h], 0.95, 'cloth'))
+            
+            if not detections:
+                return []
+            
+            tracks = self.tracker.update_tracks(detections, frame=frame)
+            
+            height, width = frame.shape[:2]
+            for track in tracks:
+                if not track.is_confirmed():
+                    continue
+                
+                track_id = track.track_id
+                bbox = track.to_ltrb()
+                cx = int((bbox[0] + bbox[2]) / 2)
+                cy = int((bbox[1] + bbox[3]) / 2)
+                
+                if 0 <= cx < width and 0 <= cy < height:
+                    if track_id not in self.track_trajectories:
+                        self.track_trajectories[track_id] = deque(maxlen=self.max_trajectory_length)
+                        self.track_colors[track_id] = (255, 255, 0)
+                    self.track_trajectories[track_id].append((cx, cy))
+            
+            active_ids = {track.track_id for track in tracks if track.is_confirmed()}
+            dead_ids = set(self.track_trajectories.keys()) - active_ids
+            for dead_id in dead_ids:
+                self.track_trajectories.pop(dead_id, None)
+                self.track_colors.pop(dead_id, None)
+            
+            return tracks
+        
+        except Exception as e:
+            logger.error(f"Tracking error: {e}")
+            return []
+    
+    def _update_gmm_fast(self, frame: np.ndarray, cloth_mask: np.ndarray, tracks: list) -> None:
+        """Lightweight GMM update."""
+        if self.gmm_model is None:
+            return
+        
+        try:
+            height, width = frame.shape[:2]
+            table_mask = None
+            if self.table_mask is not None:
+                if self.table_mask.shape != (height, width):
+                    table_mask = cv2.resize(self.table_mask, (width, height))
+                else:
+                    table_mask = self.table_mask
+            
+            _, self.gmm_heatmap = self.gmm_model.infer(
+                frame, heatmap=self.gmm_heatmap,
+                alpha_start=0.008, alpha_end=0.0004,
+                table_mask=table_mask
+            )
+            
+            if self.cleaning_active and tracks:
+                for track in tracks:
+                    if not track.is_confirmed():
+                        continue
+                    
+                    track_id = track.track_id
+                    if track_id not in self.track_trajectories:
+                        continue
+                    
+                    trajectory = list(self.track_trajectories[track_id])
+                    if len(trajectory) < 2:
+                        continue
+                    
+                    bbox = track.to_ltrb()
+                    w = bbox[2] - bbox[0]
+                    h = bbox[3] - bbox[1]
+                    
+                    radius = int(min(w, h) * self.erasure_radius_factor)
+                    radius = max(radius, 12)
+                    
+                    if radius <= 0 or w <= 0 or h <= 0:
+                        continue
+                    
+                    for i in range(len(trajectory) - 1):
+                        self._erase_at_point(trajectory[i], radius, table_mask)
+        
+        except Exception as e:
+            logger.error(f"GMM update error: {e}")
+    
+    def _erase_at_point(self, point: tuple, radius: int, table_mask: np.ndarray) -> None:
+        """Fast point-based erasure."""
+        if self.gmm_heatmap is None or radius <= 0:
+            return
+        
+        x, y = point
+        height, width = self.gmm_heatmap.shape
+        
+        y_min = max(0, y - radius)
+        y_max = min(height, y + radius)
+        x_min = max(0, x - radius)
+        x_max = min(width, x + radius)
+        
+        if y_min >= y_max or x_min >= x_max:
+            return
+        
+        y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
+        distance_sq = (x_indices - x)**2 + (y_indices - y)**2
+        
+        gaussian = np.exp(-distance_sq / (2 * (radius * self.gaussian_sigma_factor)**2))
+        
+        if table_mask is not None:
+            gaussian = gaussian * table_mask[y_min:y_max, x_min:x_max]
+        
+        decay = 0.025 * gaussian
+        self.gmm_heatmap[y_min:y_max, x_min:x_max] = np.maximum(
+            0, self.gmm_heatmap[y_min:y_max, x_min:x_max] - decay
+        )
+    
+    def _update_cleaning_status(self, cloth_mask: np.ndarray) -> str:
+        """Update cleaning status."""
+        has_cloth = np.sum(cloth_mask) > 100
+        
+        if has_cloth:
+            self.detection_frames_count += 1
+            self.no_detection_frames_count = 0
+        else:
+            self.no_detection_frames_count += 1
+            self.detection_frames_count = 0
+        
+        if not self.cleaning_active and self.detection_frames_count >= self.cleaning_start_threshold:
+            self.cleaning_active = True
+            return "CLEANING STARTED"
+        elif self.cleaning_active and self.no_detection_frames_count >= self.cleaning_stop_threshold:
+            self.cleaning_active = False
+            return "CLEANING STOPPED"
+        
+        return "CLEANING ACTIVE" if self.cleaning_active else "NO CLEANING"
+    
+    def _create_visualization(self, frame: np.ndarray, cloth_mask: np.ndarray, 
+                            tracks: list, cleaning_status: str) -> np.ndarray:
+        """Create fast visualization."""
+        result = frame.copy()
+        
+        if np.sum(cloth_mask) > 0:
+            overlay = result.copy()
+            cloth_pixels = cloth_mask > 0
+            overlay[cloth_pixels] = [0, 255, 0]
+            result[cloth_pixels] = cv2.addWeighted(
+                frame[cloth_pixels], 0.7, overlay[cloth_pixels], 0.3, 0
+            )
+        
+        if self.gmm_heatmap is not None and self.gmm_heatmap.max() > 0:
+            height, width = result.shape[:2]
+            heatmap_resized = cv2.resize(self.gmm_heatmap, (width, height))
+            heatmap_colored = cv2.applyColorMap(
+                (heatmap_resized * 255).astype(np.uint8), cv2.COLORMAP_JET
+            )
+            significant = heatmap_resized > 0.1
+            result[significant] = cv2.addWeighted(
+                frame[significant], 0.6, heatmap_colored[significant], 0.4, 0
+            )
+        
+        if tracks:
+            for track in tracks:
+                if track.is_confirmed():
+                    bbox = track.to_ltrb()
+                    cx, cy = int((bbox[0] + bbox[2])/2), int((bbox[1] + bbox[3])/2)
+                    cv2.circle(result, (cx, cy), 4, (0, 0, 255), -1)
+        
+        status_color = (0, 255, 0) if "ACTIVE" in cleaning_status else (150, 150, 150)
+        cv2.putText(result, cleaning_status, (20, 40),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, status_color, 2)
+        
+        return result
+    
+    def get_latest_frame(self) -> np.ndarray:
+        """Get latest processed frame."""
+        frame, _ = self.frame_buffer.get_latest()
+        return frame
+    
+    def get_stats(self) -> dict:
+        """Get stats."""
+        with self.frame_buffer.lock:
+            avg_time = np.mean(self.frame_times) if len(self.frame_times) > 0 else 0.033
+            fps = 1.0 / avg_time if avg_time > 0 else 0
+            return {
+                "buffered_frames": len(self.frame_buffer.frames),
+                "avg_fps": fps,
+                "queue_size": self.input_queue.qsize(),
+                "is_running": self.is_running
+            }
+
+
+# ==================== FASTAPI APP ====================
+
+app = FastAPI(title="Hygiene Monitor Live Stream", version="1.0.0")
+
+# Active streams: {stream_id: {"monitor": LiveHygieneMonitor, "cap": VideoCapture, "thread": Thread}}
+active_streams = {}
+streams_lock = Lock()
+
+
+def _get_model_files(camera_path: str) -> tuple:
+    """Extract GMM and mask paths from camera directory."""
+    if not os.path.isdir(camera_path):
+        raise ValueError(f"Camera path not found: {camera_path}")
+    
+    gmm_path = os.path.join(camera_path, "gmm_model.joblib")
+    mask_path = os.path.join(camera_path, "mask.png")
+    
+    if not os.path.exists(gmm_path):
+        raise ValueError(f"GMM model not found: {gmm_path}")
+    if not os.path.exists(mask_path):
+        raise ValueError(f"Mask not found: {mask_path}")
+    
+    return gmm_path, mask_path
+
+
+def _stream_worker(stream_id: str, rtmp_url: str, gmm_path: str, mask_path: str):
+    """Background worker for streaming."""
+    try:
+        monitor = LiveHygieneMonitor(
+            segformer_path="models/segformer_model",
+            max_buffer_frames=30
+        )
+        
+        if not monitor.load_gmm_model(gmm_path):
+            logger.error(f"[{stream_id}] Failed to load GMM model")
+            return
+        
+        if not monitor.load_table_mask(mask_path):
+            logger.error(f"[{stream_id}] Failed to load mask")
+            return
+        
+        # === INITIALIZE ALERT MANAGER - ADD THIS ===
+        webhook_url = os.getenv("DISCORD_WEBHOOK_URL")  # From environment
+        if webhook_url:
+            monitor.alert_manager = DiscordAlertManager(webhook_url=webhook_url)
+            monitor.current_camera_name = stream_id  # Or pass from request
+            logger.info(f"[{stream_id}] Alert manager initialized")
+        
+        monitor.start_processing()
+        
+        cap = cv2.VideoCapture(rtmp_url)
+        if not cap.isOpened():
+            logger.error(f"[{stream_id}] Failed to connect to RTMP: {rtmp_url}")
+            monitor.stop_processing()
+            return
+        
+        # Update active stream
+        with streams_lock:
+            if stream_id in active_streams:
+                active_streams[stream_id]["monitor"] = monitor
+                active_streams[stream_id]["cap"] = cap
+                active_streams[stream_id]["connected"] = True
+        
+        frame_count = 0
+        logger.info(f"[{stream_id}] Connected to {rtmp_url}")
+        
+        while True:
+            with streams_lock:
+                if stream_id not in active_streams or not active_streams[stream_id]["running"]:
+                    break
+            
+            ret, frame = cap.read()
+            if not ret:
+                logger.warning(f"[{stream_id}] RTMP connection lost, reconnecting...")
+                cap.release()
+                time.sleep(2)
+                cap = cv2.VideoCapture(rtmp_url)
+                continue
+            
+            monitor.add_frame(frame)
+            frame_count += 1
+            
+            if frame_count % 100 == 0:
+                stats = monitor.get_stats()
+                logger.info(f"[{stream_id}] Frames: {frame_count}, FPS: {stats['avg_fps']:.1f}")
+    
+    except Exception as e:
+        logger.error(f"[{stream_id}] Stream error: {e}")
+    
+    finally:
+        with streams_lock:
+            if stream_id in active_streams:
+                if active_streams[stream_id]["cap"]:
+                    active_streams[stream_id]["cap"].release()
+                if active_streams[stream_id]["monitor"]:
+                    active_streams[stream_id]["monitor"].stop_processing()
+                active_streams[stream_id]["connected"] = False
+        
+        logger.info(f"[{stream_id}] Stream closed")
+
+
+# ==================== ENDPOINTS ====================
+
+@app.post("/stream/start")
+async def start_stream(request: StreamStartRequest):
+    """Start a new live stream."""
+    stream_id = f"stream_{int(time.time() * 1000)}"
+    
+    try:
+        # Extract model files from camera path
+        gmm_path, mask_path = _get_model_files(request.camera_path)
+        
+        # Create stream entry
+        with streams_lock:
+            active_streams[stream_id] = {
+                "running": True,
+                "connected": False,
+                "monitor": None,
+                "cap": None,
+                "thread": None,
+                "camera_path": request.camera_path
+            }
+        
+        # Start background worker thread
+        thread = Thread(
+            target=_stream_worker,
+            args=(stream_id, request.rtmp_input_url, gmm_path, mask_path),
+            daemon=True
+        )
+        thread.start()
+        
+        with streams_lock:
+            active_streams[stream_id]["thread"] = thread
+        
+        logger.info(f"Stream {stream_id} started")
+        return {
+            "stream_id": stream_id,
+            "status": "starting",
+            "message": f"Stream {stream_id} is starting, will connect to {request.rtmp_input_url}"
+        }
+    
+    except Exception as e:
+        logger.error(f"Failed to start stream: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.post("/stream/stop")
+async def stop_stream(request: StreamStopRequest):
+    """Stop a live stream."""
+    stream_id = request.stream_id
+    
+    with streams_lock:
+        if stream_id not in active_streams:
+            raise HTTPException(status_code=404, detail=f"Stream {stream_id} not found")
+        
+        active_streams[stream_id]["running"] = False
+    
+    logger.info(f"Stream {stream_id} stop requested")
+    return {"stream_id": stream_id, "status": "stopping"}
+
+
+@app.get("/stream/status/{stream_id}")
+async def get_stream_status(stream_id: str):
+    """Get stream status."""
+    with streams_lock:
+        if stream_id not in active_streams:
+            raise HTTPException(status_code=404, detail=f"Stream {stream_id} not found")
+        
+        stream_data = active_streams[stream_id]
+        monitor = stream_data["monitor"]
+        
+        stats = monitor.get_stats() if monitor else {}
+        
+        return {
+            "stream_id": stream_id,
+            "connected": stream_data["connected"],
+            "running": stream_data["running"],
+            "camera_path": stream_data["camera_path"],
+            "fps": stats.get("avg_fps", 0),
+            "buffered_frames": stats.get("buffered_frames", 0),
+            "queue_size": stats.get("queue_size", 0)
+        }
+
+
+@app.get("/stream/video/{stream_id}")
+async def stream_video(stream_id: str):
+    """Stream video frames via MJPEG."""
+    with streams_lock:
+        if stream_id not in active_streams:
+            raise HTTPException(status_code=404, detail=f"Stream {stream_id} not found")
+        
+        monitor = active_streams[stream_id]["monitor"]
+    
+    if not monitor:
+        raise HTTPException(status_code=503, detail="Monitor not ready")
+    
+    async def frame_generator():
+        while True:
+            with streams_lock:
+                if stream_id not in active_streams or not active_streams[stream_id]["running"]:
+                    break
+            
+            frame = monitor.get_latest_frame()
+            if frame is not None:
+                _, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 80])
+                yield (b'--frame\r\n'
+                       b'Content-Type: image/jpeg\r\n'
+                       b'Content-Length: ' + str(len(buffer)).encode() + b'\r\n\r\n'
+                       + buffer.tobytes() + b'\r\n')
+            else:
+                await asyncio.sleep(0.01)
+    
+    return StreamingResponse(
+        frame_generator(),
+        media_type="multipart/x-mixed-replace; boundary=frame"
+    )
+
+
+@app.get("/streams")
+async def list_streams():
+    """List all active streams."""
+    with streams_lock:
+        streams_list = []
+        for stream_id, data in active_streams.items():
+            monitor = data["monitor"]
+            stats = monitor.get_stats() if monitor else {}
+            
+            streams_list.append({
+                "stream_id": stream_id,
+                "connected": data["connected"],
+                "running": data["running"],
+                "camera_path": data["camera_path"],
+                "fps": stats.get("avg_fps", 0),
+                "buffered_frames": stats.get("buffered_frames", 0)
+            })
+        
+        return {"total_streams": len(streams_list), "streams": streams_list}
+
+
+@app.post("/stream/restart/{stream_id}")
+async def restart_stream(stream_id: str):
+    """Restart a stream."""
+    with streams_lock:
+        if stream_id not in active_streams:
+            raise HTTPException(status_code=404, detail=f"Stream {stream_id} not found")
+        
+        active_streams[stream_id]["running"] = False
+    
+    await asyncio.sleep(2)
+    
+    with streams_lock:
+        data = active_streams[stream_id]
+        data["running"] = True
+    
+    return {"stream_id": stream_id, "status": "restarting"}
+
+@app.post("/camera/extract_frame")
+async def extract_frame_from_rtmp(request: dict):
+    """
+    Extract a single frame from RTMP stream for corner selection.
+    
+    Request body:
+    {
+        "rtmp_url": "rtmp://192.168.1.100:1935/live/kitchen",
+        "camera_name": "kitchen"
+    }
+    
+    Returns:
+    {
+        "success": true,
+        "frame_base64": "base64_encoded_image",
+        "frame_dimensions": {"width": 1920, "height": 1080}
+    }
+    """
+    try:
+        rtmp_url = request.get("rtmp_url")
+        camera_name = request.get("camera_name")
+        
+        if not rtmp_url or not camera_name:
+            raise HTTPException(status_code=400, detail="Missing rtmp_url or camera_name")
+        
+        # Connect to RTMP stream
+        cap = cv2.VideoCapture(rtmp_url)
+        if not cap.isOpened():
+            raise HTTPException(status_code=400, detail=f"Failed to connect to RTMP: {rtmp_url}")
+        
+        # Read first frame
+        ret, frame = cap.read()
+        cap.release()
+        
+        if not ret:
+            raise HTTPException(status_code=400, detail="Failed to read frame from RTMP stream")
+        import base64
+        # Convert frame to base64 for frontend display
+        _, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 95])
+        frame_base64 = base64.b64encode(buffer).decode('utf-8')
+        
+        # Store frame temporarily for training (optional - could store in memory cache)
+        temp_dir = "temp_frames"
+        os.makedirs(temp_dir, exist_ok=True)
+        temp_frame_path = os.path.join(temp_dir, f"{camera_name}_reference.jpg")
+        cv2.imwrite(temp_frame_path, frame)
+        
+        return {
+            "success": True,
+            "frame_base64": frame_base64,
+            "frame_dimensions": {
+                "width": frame.shape[1],
+                "height": frame.shape[0]
+            },
+            "temp_frame_path": temp_frame_path
+        }
+        
+    except Exception as e:
+        logger.error(f"Extract frame error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/camera/train_gmm")
+async def train_gmm_from_rtmp(request: dict):
+    """
+    Train GMM model from RTMP stream using N corner points (minimum 4).
+    
+    Request body:
+    {
+        "rtmp_url": "rtmp://192.168.1.100:1935/live/kitchen",
+        "camera_name": "kitchen",
+        "corner_points": [
+            {"x": 100, "y": 50},
+            {"x": 400, "y": 45},
+            {"x": 700, "y": 55},
+            {"x": 800, "y": 60},
+            {"x": 850, "y": 300},
+            {"x": 850, "y": 600},
+            {"x": 400, "y": 620},
+            {"x": 50, "y": 580},
+            {"x": 45, "y": 300}
+        ],  // Can be 4+ points for curved tables
+        "max_frames": 250,
+        "use_perspective_warp": false  // NEW: Set false for non-rectangular tables
+    }
+    """
+    try:
+        rtmp_url = request.get("rtmp_url")
+        camera_name = request.get("camera_name")
+        corner_points = request.get("corner_points")
+        max_frames = request.get("max_frames", 250)
+        use_perspective_warp = request.get("use_perspective_warp", False)  # NEW
+        
+        # Validation
+        if not rtmp_url or not camera_name or not corner_points:
+            raise HTTPException(status_code=400, detail="Missing required parameters")
+        
+        if len(corner_points) < 4:
+            raise HTTPException(status_code=400, detail="Minimum 4 corner points required")
+        
+        logger.info(f"Starting GMM training for camera: {camera_name} with {len(corner_points)} points")
+        
+        # ===== STEP 1: Connect to RTMP and capture frames =====
+        cap = cv2.VideoCapture(rtmp_url)
+        if not cap.isOpened():
+            raise HTTPException(status_code=400, detail=f"Failed to connect to RTMP: {rtmp_url}")
+        
+        ret, first_frame = cap.read()
+        if not ret:
+            cap.release()
+            raise HTTPException(status_code=400, detail="Failed to read from RTMP stream")
+        
+        h, w = first_frame.shape[:2]
+        
+        # ===== STEP 2: Create polygon mask from N points =====
+        pts_polygon = np.array([
+            [point['x'], point['y']] for point in corner_points
+        ], dtype=np.int32)
+        
+        # Create binary mask for the table area
+        table_mask = np.zeros((h, w), dtype=np.uint8)
+        cv2.fillPoly(table_mask, [pts_polygon], 255)
+        
+        # ===== STEP 3: Decide transformation strategy =====
+        import tempfile
+        temp_dir = tempfile.mkdtemp()
+        frame_count = 0
+        
+        if use_perspective_warp and len(corner_points) == 4:
+            # ===== STRATEGY A: Perspective warp (rectangular tables only) =====
+            logger.info("Using perspective warp for rectangular table")
+            
+            pts_src = np.array([
+                [corner_points[0]['x'], corner_points[0]['y']],
+                [corner_points[1]['x'], corner_points[1]['y']],
+                [corner_points[2]['x'], corner_points[2]['y']],
+                [corner_points[3]['x'], corner_points[3]['y']]
+            ], dtype=np.float32)
+            
+            pts_dst = np.array([
+                [0, 0], [w, 0], [w, h], [0, h]
+            ], dtype=np.float32)
+            
+            matrix = cv2.getPerspectiveTransform(pts_src, pts_dst)
+            
+            # Capture and warp frames
+            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+            while frame_count < max_frames:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                warped = cv2.warpPerspective(frame, matrix, (w, h))
+                frame_path = os.path.join(temp_dir, f'b{frame_count:05d}.png')
+                cv2.imwrite(frame_path, warped)
+                frame_count += 1
+                
+                if frame_count % 50 == 0:
+                    logger.info(f"Captured {frame_count}/{max_frames} frames")
+            
+            # For warped images, mask should be full frame (already aligned)
+            final_mask = np.ones((h, w), dtype=np.uint8) * 255
+            
+        else:
+            # ===== STRATEGY B: Direct masking (curved/complex tables) =====
+            logger.info(f"Using direct masking for {len(corner_points)}-point polygon (curved table)")
+            
+            # Capture frames WITHOUT warping, apply mask during inference
+            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+            while frame_count < max_frames:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                # Apply mask to frame (zero out outside table area)
+                masked_frame = cv2.bitwise_and(frame, frame, mask=table_mask)
+                
+                frame_path = os.path.join(temp_dir, f'b{frame_count:05d}.png')
+                cv2.imwrite(frame_path, masked_frame)
+                frame_count += 1
+                
+                if frame_count % 50 == 0:
+                    logger.info(f"Captured {frame_count}/{max_frames} frames")
+            
+            # Use original polygon mask
+            final_mask = table_mask
+        
+        cap.release()
+        
+        if frame_count == 0:
+            raise HTTPException(status_code=400, detail="No frames captured")
+        
+        logger.info(f"Captured {frame_count} frames, starting GMM training...")
+        
+        # ===== STEP 4: Train GMM =====
+        from GMM import GMM
+        gmm = GMM(temp_dir, frame_count, alpha=0.05)
+        gmm.train(K=4)
+        logger.info("GMM training complete")
+        
+        # ===== STEP 5: Save artifacts =====
+        camera_path = os.path.join("models", camera_name)
+        os.makedirs(camera_path, exist_ok=True)
+        
+        # 1. Save GMM model
+        gmm_path = os.path.join(camera_path, "gmm_model.joblib")
+        gmm.save_model(gmm_path)
+        
+        # 2. Save mask (polygon-based, not rectangular)
+        mask_path = os.path.join(camera_path, "mask.png")
+        cv2.imwrite(mask_path, final_mask)
+        logger.info(f"Saved {len(corner_points)}-point polygon mask to {mask_path}")
+        
+        # 3. Create thumbnail with polygon overlay
+        thumb_frame = first_frame.copy()
+        
+        # Draw filled polygon with transparency
+        overlay = thumb_frame.copy()
+        cv2.fillPoly(overlay, [pts_polygon], (0, 255, 0))
+        cv2.addWeighted(thumb_frame, 0.7, overlay, 0.3, 0, thumb_frame)
+        
+        # Draw polygon border
+        cv2.polylines(thumb_frame, [pts_polygon], True, (0, 255, 0), 3)
+        
+        # Draw corner points with numbers
+        colors = [
+            (255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0),
+            (255, 0, 255), (0, 255, 255), (128, 0, 128), (255, 128, 0)
+        ]
+        
+        for i, point in enumerate(corner_points):
+            x, y = point['x'], point['y']
+            color = colors[i % len(colors)]
+            
+            cv2.circle(thumb_frame, (x, y), 8, color, -1)
+            cv2.circle(thumb_frame, (x, y), 10, (255, 255, 255), 2)
+            
+            # Point number
+            cv2.putText(thumb_frame, str(i+1), (x+15, y), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
+        
+        # Camera name label
+        cv2.putText(thumb_frame, camera_name, (30, 50),
+                   cv2.FONT_HERSHEY_DUPLEX, 1.5, (255, 255, 255), 3)
+        cv2.putText(thumb_frame, camera_name, (30, 50),
+                   cv2.FONT_HERSHEY_DUPLEX, 1.5, (0, 255, 0), 2)
+        
+        # Add point count indicator
+        cv2.putText(thumb_frame, f"{len(corner_points)} points", (30, 90),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)
+        
+        thumb_path = os.path.join(camera_path, "thumb.png")
+        cv2.imwrite(thumb_path, thumb_frame)
+        
+        # 4. Save polygon metadata (NEW - for reconstruction)
+        metadata = {
+            "camera_name": camera_name,
+            "num_points": len(corner_points),
+            "corner_points": corner_points,
+            "frame_dimensions": {"width": w, "height": h},
+            "use_perspective_warp": use_perspective_warp,
+            "training_date": datetime.now().isoformat()
+        }
+        
+        import json
+        metadata_path = os.path.join(camera_path, "metadata.json")
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f, indent=2)
+        
+        logger.info(f"Saved metadata to {metadata_path}")
+        
+        # Cleanup
+        import shutil
+        shutil.rmtree(temp_dir)
+        
+        logger.info(f"✅ Camera '{camera_name}' training complete with {len(corner_points)}-point polygon!")
+        
+        return {
+            "success": True,
+            "camera_name": camera_name,
+            "camera_path": camera_path,
+            "frames_captured": frame_count,
+            "polygon_points": len(corner_points),
+            "use_perspective_warp": use_perspective_warp,
+            "model_files": {
+                "gmm_model": gmm_path,
+                "mask": mask_path,
+                "thumbnail": thumb_path,
+                "metadata": metadata_path
+            }
+        }
+        
+    except Exception as e:
+        logger.error(f"GMM training error: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/cameras")
+async def list_cameras():
+    """
+    List all trained cameras with their metadata.
+    
+    Returns:
+    {
+        "cameras": [
+            {
+                "name": "kitchen",
+                "path": "models/kitchen",
+                "thumbnail": "models/kitchen/thumb.png",
+                "has_gmm_model": true,
+                "has_mask": true
+            }
+        ]
+    }
+    """
+    try:
+        cameras = []
+        models_dir = "models"
+        
+        if not os.path.exists(models_dir):
+            return {"cameras": []}
+        
+        for camera_name in os.listdir(models_dir):
+            camera_path = os.path.join(models_dir, camera_name)
+            
+            if not os.path.isdir(camera_path):
+                continue
+            
+            gmm_path = os.path.join(camera_path, "gmm_model.joblib")
+            mask_path = os.path.join(camera_path, "mask.png")
+            thumb_path = os.path.join(camera_path, "thumb.png")
+            
+            cameras.append({
+                "name": camera_name,
+                "path": camera_path,
+                "thumbnail": thumb_path if os.path.exists(thumb_path) else None,
+                "has_gmm_model": os.path.exists(gmm_path),
+                "has_mask": os.path.exists(mask_path)
+            })
+        
+        return {"cameras": cameras}
+        
+    except Exception as e:
+        logger.error(f"List cameras error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/camera/{camera_name}")
+async def delete_camera(camera_name: str):
+    """
+    Delete a trained camera and all its files.
+    """
+    try:
+        camera_path = os.path.join("models", camera_name)
+        
+        if not os.path.exists(camera_path):
+            raise HTTPException(status_code=404, detail=f"Camera '{camera_name}' not found")
+        
+        import shutil
+        shutil.rmtree(camera_path)
+        
+        logger.info(f"Deleted camera: {camera_name}")
+        
+        return {
+            "success": True,
+            "message": f"Camera '{camera_name}' deleted successfully"
+        }
+        
+    except Exception as e:
+        logger.error(f"Delete camera error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    with streams_lock:
+        stream_count = len(active_streams)
+    
+    return {
+        "status": "healthy",
+        "active_streams": stream_count,
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=8000)