Upload 4 files

GMM.py

@@ -0,0 +1,949 @@
+import numpy as np
+import cv2 as cv
+import os
+from numpy.linalg import norm, inv
+from scipy.stats import multivariate_normal as mv_norm
+import joblib  # or import pickle
+import os
+import torch
+from torch.distributions import MultivariateNormal
+import torch.nn.functional as F
+init_weight = [0.7, 0.11, 0.1, 0.09]
+init_u = np.zeros(3)
+# initial Covariance matrix
+init_sigma = 225*np.eye(3)
+init_alpha = 0.05
+
+class GMM():
+    def __init__(self, data_dir, train_num, alpha=init_alpha):
+        self.data_dir = data_dir
+        self.train_num = train_num
+        self.alpha = alpha
+        self.img_shape = None
+
+        self.weight = None
+        self.mu = None
+        self.sigma = None
+        self.K = None
+        self.B = None
+
+    def check(self, pixel, mu, sigma):
+        '''
+        Check whether a pixel matches a Gaussian distribution.
+        Matching means the Mahalanobis distance is less than 2.5.
+        '''
+        # Convert to torch tensors on same device
+        if isinstance(mu, np.ndarray):
+            mu = torch.from_numpy(mu).float()
+        if isinstance(sigma, np.ndarray):
+            sigma = torch.from_numpy(sigma).float()
+        if isinstance(pixel, np.ndarray):
+            pixel = torch.from_numpy(pixel).float()
+        
+        # Ensure all are on the same device
+        device = mu.device
+        pixel = pixel.to(device)
+        sigma = sigma.to(device)
+
+        # Compute Mahalanobis distance
+        delta = pixel - mu
+        sigma_inv = torch.linalg.inv(sigma)
+        d_squared = delta @ sigma_inv @ delta
+        d = torch.sqrt(d_squared + 1e-5)
+
+        return d.item() < 0.1
+        
+    def rgba_to_rgb_for_processing(image_path):
+        img = cv.imread(image_path, cv.IMREAD_UNCHANGED)
+        
+        if img.shape[2] == 4:  # RGBA
+            # Create white background
+            rgb_img = np.ones((img.shape[0], img.shape[1], 3), dtype=np.uint8) * 255
+            
+            # Alpha blending: blend with white background
+            alpha = img[:, :, 3:4] / 255.0
+            rgb_img = rgb_img * (1 - alpha) + img[:, :, :3] * alpha
+            
+            return rgb_img.astype(np.uint8)
+        else:
+            return img
+
+    
+    def train(self, K=4):
+        '''
+        train model with GPU acceleration
+        '''
+        self.K = K
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Using device: {device}")
+        
+        file_list = []
+        for i in range(self.train_num):
+            file_name = os.path.join(self.data_dir, 'b%05d' % i + '.png')
+            file_list.append(file_name)
+
+        # Initialize with first image
+        img_init = cv.imread(file_list[0])
+        img_shape = img_shape = img_init.shape
+        self.img_shape = img_shape
+        height, width, channels = img_shape
+        
+        # Initialize model parameters on GPU
+        self.weight = torch.full((height, width, K), 1.0/K, 
+                            dtype=torch.float32, device=device)
+        self.mu = torch.zeros(height, width, K, 3, 
+                        dtype=torch.float32, device=device)
+        self.sigma = torch.zeros(height, width, K, 3, 3, 
+                            dtype=torch.float32, device=device)
+        self.B = torch.ones((height, width), 
+                        dtype=torch.int32, device=device)
+        
+        # Initialize mu with first image values
+        img_tensor = torch.from_numpy(img_init).float().to(device)
+        for k in range(K):
+            self.mu[:, :, k, :] = img_tensor
+        
+        # Initialize sigma with identity matrix * 225
+        self.sigma[:] = torch.eye(3, device=device) * 225
+        
+        # Training loop
+        for file in file_list:
+            print('training:{}'.format(file))
+            img = cv.imread(file)
+            img_tensor = torch.from_numpy(img).float().to(device)  # (H,W,3)
+            
+            # Check matches for all pixels
+            matches = torch.full((height, width), -1, dtype=torch.long, device=device)
+            
+            for k in range(K):
+                # Calculate Mahalanobis distance for each distribution
+                delta = img_tensor.unsqueeze(2) - self.mu  # (H,W,K,3)
+                sigma_inv = torch.linalg.inv(self.sigma)  # (H,W,K,3,3)
+                
+                # Compute (x-μ)T Σ^-1 (x-μ)
+                temp = torch.einsum('hwki,hwkij->hwkj', delta, sigma_inv)
+                mahalanobis = torch.sqrt(torch.einsum('hwki,hwki->hwk', temp, delta))
+                
+                # Update matches where distance < 2.5 and not already matched
+                match_mask = (mahalanobis[:,:,k] < 2.5) & (matches == -1)
+                matches[match_mask] = k
+            
+            # Process matched pixels
+            for k in range(K):
+                # Get mask for current distribution matches
+                mask = matches == k
+                if mask.any():
+                    # Get matched pixels
+                    matched_pixels = img_tensor[mask]  # (N,3)
+                    matched_mu = self.mu[:,:,k,:][mask]  # (N,3)
+                    matched_sigma = self.sigma[:,:,k,:,:][mask]  # (N,3,3)
+                    
+                    try:
+                        # Create multivariate normal distribution
+                        mvn = MultivariateNormal(matched_mu, 
+                                            covariance_matrix=matched_sigma)
+                        
+                        # Calculate rho
+                        rho = self.alpha * torch.exp(mvn.log_prob(matched_pixels))
+                        
+                        # Update weights
+                        self.weight[:,:,k][mask] = (1 - self.alpha) * self.weight[:,:,k][mask] + self.alpha
+                        
+                        # Update mu
+                        delta = matched_pixels - matched_mu
+                        self.mu[:,:,k,:][mask] += rho.unsqueeze(1) * delta
+                        
+                        # Update sigma
+                        delta_outer = torch.einsum('bi,bj->bij', delta, delta)
+                        sigma_update = rho.unsqueeze(1).unsqueeze(2) * (delta_outer - matched_sigma)
+                        self.sigma[:,:,k,:,:][mask] += sigma_update
+                        
+                    except RuntimeError as e:
+                        print(f"Error updating distribution {k}: {e}")
+                        continue
+            
+            # Process non-matched pixels
+            non_matched = matches == -1
+            if non_matched.any():
+                # Find least probable distribution for each non-matched pixel
+                weight_non_matched = self.weight[non_matched]  # shape: (N, K)
+                min_weight_idx = torch.argmin(weight_non_matched, dim=1)  # shape: (N,)
+                
+                # Create flat indices of non-matched pixels
+                non_matched_indices = non_matched.nonzero(as_tuple=False)  # shape: (N, 2)
+
+                for k in range(K):
+                    # Find positions where min_weight_idx == k
+                    k_mask = (min_weight_idx == k)
+                    if k_mask.any():
+                        selected_indices = non_matched_indices[k_mask]  # shape: (M, 2)
+                        y_idx = selected_indices[:, 0]
+                        x_idx = selected_indices[:, 1]
+                        
+                        # Update mu and sigma
+                        self.mu[y_idx, x_idx, k, :] = img_tensor[y_idx, x_idx]
+                        self.sigma[y_idx, x_idx, k, :, :] = torch.eye(3, device=device) * 225
+            
+            # Convert to numpy for reordering and debug prints
+            weight_np = self.weight.cpu().numpy()
+            mu_np = self.mu.cpu().numpy()
+            sigma_np = self.sigma.cpu().numpy()
+            B_np = self.B.cpu().numpy()
+            
+            print('img:{}'.format(img[100][100]))
+            print('weight:{}'.format(weight_np[100][100]))
+        
+        # Update numpy arrays for reorder
+        self.weight = weight_np
+        self.mu = mu_np
+        self.sigma = sigma_np
+        self.B = B_np
+        
+        self.reorder()
+        for i in range(self.K):
+            print('u:{}'.format(self.mu[100][100][i]))
+        
+        # Move back to GPU for next iteration
+        self.weight = torch.from_numpy(self.weight).to(device)
+        self.mu = torch.from_numpy(self.mu).to(device)
+        self.sigma = torch.from_numpy(self.sigma).to(device)
+        self.B = torch.from_numpy(self.B).to(device)
+
+    def save_model(self, file_path):
+        """
+        Save the trained model to a file
+        """
+        # Only make directories if there is a directory in the path
+        dir_name = os.path.dirname(file_path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+
+        joblib.dump({
+            'weight': self.weight,
+            'mu': self.mu,
+            'sigma': self.sigma,
+            'K': self.K,
+            'B': self.B,
+            'img_shape': self.img_shape,
+            'alpha': self.alpha,
+            'data_dir': self.data_dir,
+            'train_num': self.train_num
+        }, file_path)
+
+        print(f"Model saved to {file_path}")
+
+    @classmethod
+    def load_model(cls, file_path):
+        """
+        Load a trained model from file
+        """
+        data = joblib.load(file_path)
+        
+        # Create new instance
+        gmm = cls(data['data_dir'], data['train_num'], data['alpha'])
+        
+        # Restore all attributes
+        gmm.weight = data['weight']
+        gmm.mu = data['mu']
+        gmm.sigma = data['sigma']
+        gmm.K = data['K']
+        gmm.B = data['B']
+        gmm.img_shape = data['img_shape']
+        gmm.image_shape = data['img_shape']
+
+        print(f"Model loaded from {file_path}")
+        return gmm
+    # @classmethod
+    # def load_model(cls, file_path):
+    #     """
+    #     Load a trained model safely onto CPU, even if saved from GPU.
+    #     """
+    #     import pickle
+    
+    #     def cpu_load(path):
+    #         with open(path, "rb") as f:
+    #             unpickler = pickle._Unpickler(f)
+    #             unpickler.persistent_load = lambda saved_id: torch.load(saved_id, map_location="cpu")
+    #             return unpickler.load()
+    
+    #     # Force joblib to use pickle with CPU-mapped tensors
+    #     data = cpu_load(file_path)
+    
+    #     # Create instance
+    #     gmm = cls(data['data_dir'], data['train_num'], data['alpha'])
+    
+        # Assign all attributes (already CPU tensors now)
+        gmm.weight = data['weight']
+        gmm.mu = data['mu']
+        gmm.sigma = data['sigma']
+        gmm.K = data['K']
+        gmm.B = data['B']
+        gmm.img_shape = data['img_shape']
+        gmm.image_shape = data['img_shape']
+    
+        print(f"✅ GMM model loaded on CPU from {file_path}")
+        return gmm
+
+    
+
+
+    def reorder(self, T=0.90):
+        '''
+        Reorder the estimated components based on the ratio pi / the norm of standard deviation.
+        The first B components are chosen as background components.
+        The default threshold is 0.90.
+        '''
+        epsilon = 1e-6  # to prevent divide-by-zero
+
+        for i in range(self.img_shape[0]):
+            for j in range(self.img_shape[1]):
+                k_weight = self.weight[i][j]
+                k_norm = []
+
+                for k in range(self.K):
+                    cov = self.sigma[i][j][k]
+                    try:
+                        if np.all(np.linalg.eigvals(cov) >= 0):
+                            # stddev = np.sqrt(cov)
+                            epsilon = 1e-6
+                            stddev = np.sqrt(np.maximum(cov, epsilon))
+                            k_norm.append(norm(stddev))
+                        else:
+                            k_norm.append(epsilon)
+                    except:
+                        k_norm.append(epsilon)
+
+                k_norm = np.array(k_norm)
+                ratio = k_weight / (k_norm + epsilon)
+                descending_order = np.argsort(-ratio)
+
+                self.weight[i][j] = self.weight[i][j][descending_order]
+                self.mu[i][j] = self.mu[i][j][descending_order]
+                self.sigma[i][j] = self.sigma[i][j][descending_order]
+
+                cum_weight = 0
+                for index, order in enumerate(descending_order):
+                    cum_weight += self.weight[i][j][index]
+                    if cum_weight > T:
+                        self.B[i][j] = index + 1
+                        break
+    from typing import Tuple, Optional
+    
+    def region_propfill_enhancement(self, binary_mask: np.ndarray, 
+                               table_mask: Optional[np.ndarray] = None,  # ADDED parameter
+                               dilation_kernel_size: int = 5,
+                               dilation_iterations: int = 2,
+                               erosion_iterations: int = 1,
+                               fill_threshold: int = 200,
+                               min_contour_area: int = 50) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Enhance GMM binary prediction mask using dilation and region filling.
+        
+        Args:
+            binary_mask: Binary mask from GMM detection (True for detected foreground)
+            table_mask: Optional binary mask defining table area (restricts processing)
+            dilation_kernel_size: Size of dilation kernel (odd number)
+            dilation_iterations: Number of dilation iterations to connect fragments
+            erosion_iterations: Number of erosion iterations to restore original size
+            fill_threshold: Threshold for flood fill operation
+            min_contour_area: Minimum contour area to consider for processing
+            
+        Returns:
+            enhanced_mask: Improved binary mask with filled regions
+            debug_info: Dictionary containing intermediate results for debugging
+        """
+        
+        # Convert boolean mask to uint8 if needed
+        if binary_mask.dtype == bool:
+            mask_uint8 = (binary_mask * 255).astype(np.uint8)
+        else:
+            mask_uint8 = binary_mask.astype(np.uint8)
+        
+        # Apply table mask if provided - CRITICAL FIX
+        if table_mask is not None:
+            # Ensure table_mask matches dimensions
+            if table_mask.shape != mask_uint8.shape:
+                table_mask = cv.resize(table_mask.astype(np.uint8), 
+                                     (mask_uint8.shape[1], mask_uint8.shape[0]), 
+                                     interpolation=cv.INTER_NEAREST) > 0
+            # Zero out everything outside table area
+            mask_uint8[~table_mask] = 0
+        
+        # Store original for comparison
+        original_mask = mask_uint8.copy()
+        
+        # Step 1: Apply dilation to connect fragmented detections
+        kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE, 
+                                          (dilation_kernel_size, dilation_kernel_size))
+        
+        # Dilate to connect nearby fragments
+        dilated_mask = cv.dilate(mask_uint8, kernel, iterations=dilation_iterations)
+        
+        # Step 2: Apply flood fill to fill internal holes
+        filled_mask = dilated_mask.copy()
+        h, w = filled_mask.shape
+        
+        # Create flood fill mask (needs to be 2 pixels larger)
+        flood_mask = np.zeros((h + 2, w + 2), np.uint8)
+        
+        # Find contours to identify individual objects
+        contours, _ = cv.findContours(dilated_mask, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
+        
+        # Process each contour separately
+        enhanced_mask = np.zeros_like(filled_mask)
+        
+        for contour in contours:
+            # Filter out small contours
+            if cv.contourArea(contour) < min_contour_area:
+                continue
+                
+            # Create mask for this contour
+            contour_mask = np.zeros_like(filled_mask)
+            cv.drawContours(contour_mask, [contour], -1, 255, -1)
+            
+            # Get bounding rectangle
+            x, y, w_rect, h_rect = cv.boundingRect(contour)
+            
+            # Create region of interest
+            roi = contour_mask[y:y+h_rect, x:x+w_rect].copy()
+            
+            if roi.size == 0:
+                continue
+                
+            # Apply flood fill from borders to fill external areas
+            roi_filled = roi.copy()
+            roi_h, roi_w = roi_filled.shape
+            
+            # Create flood mask for ROI
+            roi_flood_mask = np.zeros((roi_h + 2, roi_w + 2), np.uint8)
+            
+            # Flood fill from all border points to mark external areas
+            border_points = []
+            # Top and bottom borders
+            for i in range(roi_w):
+                if roi_filled[0, i] == 0:
+                    border_points.append((i, 0))
+                if roi_filled[roi_h-1, i] == 0:
+                    border_points.append((i, roi_h-1))
+            
+            # Left and right borders  
+            for i in range(roi_h):
+                if roi_filled[i, 0] == 0:
+                    border_points.append((0, i))
+                if roi_filled[i, roi_w-1] == 0:
+                    border_points.append((roi_w-1, i))
+            
+            # Apply flood fill from border points
+            external_mask = np.zeros_like(roi_filled)
+            for point in border_points:
+                if roi_filled[point[1], point[0]] == 0:
+                    cv.floodFill(external_mask, roi_flood_mask, point, 255)
+            
+            # Invert to get internal areas
+            internal_mask = cv.bitwise_not(external_mask)
+            
+            # Combine with original contour
+            filled_contour = cv.bitwise_or(roi, internal_mask)
+            
+            # Place back in full image
+            enhanced_mask[y:y+h_rect, x:x+w_rect] = cv.bitwise_or(
+                enhanced_mask[y:y+h_rect, x:x+w_rect], filled_contour)
+        
+        # Step 3: Optional erosion to restore approximate original size
+        if erosion_iterations > 0:
+            erosion_kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE, 
+                                                      (dilation_kernel_size, dilation_kernel_size))
+            enhanced_mask = cv.erode(enhanced_mask, erosion_kernel, iterations=erosion_iterations)
+        
+        # Step 4: Ensure we don't lose original detections AND respect table boundary
+        enhanced_mask = cv.bitwise_or(enhanced_mask, original_mask)
+        
+        # RE-APPLY TABLE MASK - Ensure no processing outside table
+        if table_mask is not None:
+            enhanced_mask[~table_mask] = 0
+        
+        # Convert back to boolean if input was boolean
+        if binary_mask.dtype == bool:
+            enhanced_mask = enhanced_mask > 0
+        
+        # Create debug info
+        debug_info = {
+            'original_mask': original_mask,
+            'dilated_mask': dilated_mask,
+            'enhanced_mask': enhanced_mask,
+            'num_contours_processed': len([c for c in contours if cv.contourArea(c) >= min_contour_area])
+        }
+        
+        return enhanced_mask, debug_info
+    
+    def draw_heatmap_colorbar(self, frame: np.ndarray, heatmap: np.ndarray) -> np.ndarray:
+        """
+        Draw a vertical heatmap color bar on the right side of the frame.
+        
+        Args:
+            frame: Original frame
+            heatmap: Heatmap array with values 0-1
+            
+        Returns:
+            Frame with color bar overlay
+        """
+        height, width = frame.shape[:2]
+        
+        # Color bar dimensions
+        bar_width = 30
+        bar_height = int(height * 0.6)
+        bar_x = width - bar_width - 20
+        bar_y = int(height * 0.2)
+        
+        # Create gradient color bar
+        gradient = np.linspace(1, 0, bar_height).reshape(-1, 1)
+        gradient = np.tile(gradient, (1, bar_width))
+        
+        # Convert to color using JET colormap
+        gradient_colored = cv.applyColorMap((gradient * 255).astype(np.uint8), cv.COLORMAP_JET)
+        
+        # Add border and background
+        cv.rectangle(frame, (bar_x - 2, bar_y - 2), 
+                    (bar_x + bar_width + 2, bar_y + bar_height + 2), (255, 255, 255), 2)
+        cv.rectangle(frame, (bar_x - 1, bar_y - 1), 
+                    (bar_x + bar_width + 1, bar_y + bar_height + 1), (0, 0, 0), 1)
+        
+        # Place color bar
+        frame[bar_y:bar_y+bar_height, bar_x:bar_x+bar_width] = gradient_colored
+        
+        # Add labels
+        labels = ["1.0", "0.75", "0.5", "0.25", "0.0"]
+        label_positions = [0, 0.25, 0.5, 0.75, 1.0]
+        
+        for label, pos in zip(labels, label_positions):
+            y_pos = bar_y + int(pos * bar_height)
+            cv.putText(frame, label, (bar_x + bar_width + 5, y_pos + 5),
+                      cv.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1)
+        
+        # Add title
+        cv.putText(frame, "HEAT", (bar_x - 5, bar_y - 10),
+                  cv.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        
+        # Add current max value
+        max_heat = heatmap.max()
+        cv.putText(frame, f"Max: {max_heat:.2f}", (bar_x - 20, bar_y + bar_height + 20),
+                  cv.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1)
+        
+        return frame
+
+    def region_propfill_enhancement(self, binary_mask: np.ndarray, 
+                               table_mask: Optional[np.ndarray] = None,  # ADDED parameter
+                               dilation_kernel_size: int = 5,
+                               dilation_iterations: int = 2,
+                               erosion_iterations: int = 1,
+                               fill_threshold: int = 200,
+                               min_contour_area: int = 50) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Enhance GMM binary prediction mask using dilation and region filling.
+        
+        Args:
+            binary_mask: Binary mask from GMM detection (True for detected foreground)
+            table_mask: Optional binary mask defining table area (restricts processing)
+            dilation_kernel_size: Size of dilation kernel (odd number)
+            dilation_iterations: Number of dilation iterations to connect fragments
+            erosion_iterations: Number of erosion iterations to restore original size
+            fill_threshold: Threshold for flood fill operation
+            min_contour_area: Minimum contour area to consider for processing
+            
+        Returns:
+            enhanced_mask: Improved binary mask with filled regions
+            debug_info: Dictionary containing intermediate results for debugging
+        """
+        
+        # Convert boolean mask to uint8 if needed
+        if binary_mask.dtype == bool:
+            mask_uint8 = (binary_mask * 255).astype(np.uint8)
+        else:
+            mask_uint8 = binary_mask.astype(np.uint8)
+        
+        # Apply table mask if provided - CRITICAL FIX
+        if table_mask is not None:
+            # Ensure table_mask matches dimensions
+            if table_mask.shape != mask_uint8.shape:
+                table_mask = cv.resize(table_mask.astype(np.uint8), 
+                                     (mask_uint8.shape[1], mask_uint8.shape[0]), 
+                                     interpolation=cv.INTER_NEAREST) > 0
+            # Zero out everything outside table area
+            mask_uint8[~table_mask] = 0
+        
+        # Store original for comparison
+        original_mask = mask_uint8.copy()
+        
+        # Step 1: Apply dilation to connect fragmented detections
+        kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE, 
+                                          (dilation_kernel_size, dilation_kernel_size))
+        
+        # Dilate to connect nearby fragments
+        dilated_mask = cv.dilate(mask_uint8, kernel, iterations=dilation_iterations)
+        
+        # Step 2: Apply flood fill to fill internal holes
+        filled_mask = dilated_mask.copy()
+        h, w = filled_mask.shape
+        
+        # Create flood fill mask (needs to be 2 pixels larger)
+        flood_mask = np.zeros((h + 2, w + 2), np.uint8)
+        
+        # Find contours to identify individual objects
+        contours, _ = cv.findContours(dilated_mask, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
+        
+        # Process each contour separately
+        enhanced_mask = np.zeros_like(filled_mask)
+        
+        for contour in contours:
+            # Filter out small contours
+            if cv.contourArea(contour) < min_contour_area:
+                continue
+                
+            # Create mask for this contour
+            contour_mask = np.zeros_like(filled_mask)
+            cv.drawContours(contour_mask, [contour], -1, 255, -1)
+            
+            # Get bounding rectangle
+            x, y, w_rect, h_rect = cv.boundingRect(contour)
+            
+            # Create region of interest
+            roi = contour_mask[y:y+h_rect, x:x+w_rect].copy()
+            
+            if roi.size == 0:
+                continue
+                
+            # Apply flood fill from borders to fill external areas
+            roi_filled = roi.copy()
+            roi_h, roi_w = roi_filled.shape
+            
+            # Create flood mask for ROI
+            roi_flood_mask = np.zeros((roi_h + 2, roi_w + 2), np.uint8)
+            
+            # Flood fill from all border points to mark external areas
+            border_points = []
+            # Top and bottom borders
+            for i in range(roi_w):
+                if roi_filled[0, i] == 0:
+                    border_points.append((i, 0))
+                if roi_filled[roi_h-1, i] == 0:
+                    border_points.append((i, roi_h-1))
+            
+            # Left and right borders  
+            for i in range(roi_h):
+                if roi_filled[i, 0] == 0:
+                    border_points.append((0, i))
+                if roi_filled[i, roi_w-1] == 0:
+                    border_points.append((roi_w-1, i))
+            
+            # Apply flood fill from border points
+            external_mask = np.zeros_like(roi_filled)
+            for point in border_points:
+                if roi_filled[point[1], point[0]] == 0:
+                    cv.floodFill(external_mask, roi_flood_mask, point, 255)
+            
+            # Invert to get internal areas
+            internal_mask = cv.bitwise_not(external_mask)
+            
+            # Combine with original contour
+            filled_contour = cv.bitwise_or(roi, internal_mask)
+            
+            # Place back in full image
+            enhanced_mask[y:y+h_rect, x:x+w_rect] = cv.bitwise_or(
+                enhanced_mask[y:y+h_rect, x:x+w_rect], filled_contour)
+        
+        # Step 3: Optional erosion to restore approximate original size
+        if erosion_iterations > 0:
+            erosion_kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE, 
+                                                      (dilation_kernel_size, dilation_kernel_size))
+            enhanced_mask = cv.erode(enhanced_mask, erosion_kernel, iterations=erosion_iterations)
+        
+        # Step 4: Ensure we don't lose original detections AND respect table boundary
+        enhanced_mask = cv.bitwise_or(enhanced_mask, original_mask)
+        
+        # RE-APPLY TABLE MASK - Ensure no processing outside table
+        if table_mask is not None:
+            enhanced_mask[~table_mask] = 0
+        
+        # Convert back to boolean if input was boolean
+        if binary_mask.dtype == bool:
+            enhanced_mask = enhanced_mask > 0
+        
+        # Create debug info
+        debug_info = {
+            'original_mask': original_mask,
+            'dilated_mask': dilated_mask,
+            'enhanced_mask': enhanced_mask,
+            'num_contours_processed': len([c for c in contours if cv.contourArea(c) >= min_contour_area])
+        }
+        
+        return enhanced_mask, debug_info
+        
+    def visualize_mask_enhancement(self, original_mask: np.ndarray, 
+                                  enhanced_mask: np.ndarray, 
+                                  debug_info: dict,
+                                  window_prefix: str = "Enhancement"):
+        """
+        Visualize the mask enhancement process.
+        
+        Args:
+            original_mask: Original binary mask
+            enhanced_mask: Enhanced binary mask  
+            debug_info: Debug information from enhancement process
+            window_prefix: Prefix for window names
+        """
+        
+        # Convert boolean masks to uint8 for display
+        if original_mask.dtype == bool:
+            orig_display = (original_mask * 255).astype(np.uint8)
+        else:
+            orig_display = original_mask.astype(np.uint8)
+            
+        if enhanced_mask.dtype == bool:
+            enhanced_display = (enhanced_mask * 255).astype(np.uint8)
+        else:
+            enhanced_display = enhanced_mask.astype(np.uint8)
+        
+        # Show progression
+        cv.imshow(f"{window_prefix} - Original Mask", orig_display)
+        cv.imshow(f"{window_prefix} - Dilated Mask", debug_info['dilated_mask'])
+        cv.imshow(f"{window_prefix} - Enhanced Mask", enhanced_display)
+        
+        # Show difference
+        difference = cv.absdiff(enhanced_display, orig_display)
+        cv.imshow(f"{window_prefix} - Added Regions", difference)
+        
+        # print(f"Processed {debug_info['num_contours_processed']} contours")
+        
+    def infer(self, img, heatmap=None, alpha_start=0.002, alpha_end=0.0001, 
+              table_mask=None, cleaning_mask=None):
+        """
+        Inference with proper resizing to avoid spatial distortion:
+        - Preserves original aspect ratios
+        - Minimizes resize operations
+        - Ensures spatial consistency between input and output
+        """
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Store original dimensions
+        orig_H, orig_W = img.shape[:2]
+        
+        # Get model's expected dimensions
+        model_H, model_W = self.B.shape[:2]
+        
+        # Check if resizing is needed
+        needs_resize = (orig_H, orig_W) != (model_H, model_W)
+        
+        if needs_resize:
+            print(f"🔧 Resizing input from ({orig_H}, {orig_W}) to model size ({model_H}, {model_W})")
+            
+            # Use INTER_LINEAR for better quality, avoid INTER_NEAREST
+            img_resized = cv.resize(img, (model_W, model_H), interpolation=cv.INTER_LINEAR)
+            img_tensor = torch.from_numpy(img_resized).float().to(device)
+            
+            # Process table mask with same interpolation
+            if table_mask is not None:
+                print(f"🔧 Resizing table mask from {table_mask.shape} to ({model_H}, {model_W})")
+                # Use INTER_NEAREST for binary masks to preserve sharp edges
+                table_mask_resized = cv.resize(table_mask.astype(np.uint8), (model_W, model_H), 
+                                             interpolation=cv.INTER_NEAREST)
+                table_mask_tensor = torch.from_numpy(table_mask_resized > 0).bool().to(device)
+            else:
+                table_mask_tensor = torch.ones((model_H, model_W), dtype=torch.bool, device=device)
+                
+            # Resize existing heatmap if provided
+            if heatmap is not None:
+                if heatmap.shape != (model_H, model_W):
+                    heatmap_resized = cv.resize(heatmap, (model_W, model_H), interpolation=cv.INTER_LINEAR)
+                    heatmap = torch.from_numpy(heatmap_resized).float().to(device)
+                else:
+                    heatmap = torch.from_numpy(heatmap).float().to(device)
+            else:
+                heatmap = torch.zeros((model_H, model_W), dtype=torch.float32, device=device)
+                
+            working_H, working_W = model_H, model_W
+            
+        else:
+            # No resizing needed
+            img_tensor = torch.from_numpy(img).float().to(device)
+            
+            if table_mask is not None:
+                table_mask_tensor = torch.from_numpy(table_mask > 0).bool().to(device)
+            else:
+                table_mask_tensor = torch.ones((orig_H, orig_W), dtype=torch.bool, device=device)
+                
+            if heatmap is not None:
+                heatmap = torch.from_numpy(heatmap).float().to(device)
+            else:
+                heatmap = torch.zeros((orig_H, orig_W), dtype=torch.float32, device=device)
+                
+            working_H, working_W = orig_H, orig_W
+    
+        # Initialize foreground detection mask
+        detection_mask = table_mask_tensor.clone()
+    
+        # GMM processing (unchanged)
+        for k in range(self.K):
+            B_mask = (self.B >= (k + 1)).to(device)
+            B_mask = B_mask & table_mask_tensor
+            
+            mu_k = self.mu[:, :, k, :].to(device)
+            sigma_k = self.sigma[:, :, k, :, :].to(device)
+    
+            delta = img_tensor - mu_k
+            delta = delta.unsqueeze(-1)
+            sigma_inv = torch.linalg.inv(sigma_k)
+            temp = torch.matmul(sigma_inv, delta)
+            dist_sq = torch.matmul(delta.transpose(-2, -1), temp).squeeze(-1).squeeze(-1)
+            dist = torch.sqrt(dist_sq + 1e-5)
+    
+            match_mask = (dist < 7.0) & B_mask
+            detection_mask[match_mask] = False
+            img_tensor[match_mask] = mu_k[match_mask]
+    
+        # Foreground detection
+        foreground_mask = detection_mask & (img_tensor.abs().sum(dim=-1) > 0) & table_mask_tensor
+        #------------------------------------------------------------Below line was replaced with region propfill code
+        # filled_mask = foreground_mask
+
+
+        # === REGION PROPFILL ENHANCEMENT ===
+        # Convert foreground mask to numpy for processing
+        foreground_np = foreground_mask.detach().cpu().numpy()
+        table_mask_np = table_mask_tensor.detach().cpu().numpy() if table_mask_tensor is not None else None
+        # Apply region propfill enhancement with hardcoded parameters
+        enhanced_mask, debug_info = self.region_propfill_enhancement(
+            foreground_np,table_mask=table_mask_np, 
+            dilation_kernel_size=3,      # Hardcoded: size of dilation kernel
+            dilation_iterations=1,       # Hardcoded: connect nearby fragments
+            erosion_iterations=2,        # Hardcoded: restore original size
+            fill_threshold=230,          # Hardcoded: threshold for flood fill
+            min_contour_area=200         # Hardcoded: filter small noise
+        )
+        
+        # Convert enhanced mask back to tensor
+        filled_mask = torch.from_numpy(enhanced_mask).bool().to(device)
+        
+        # Optional: Print enhancement statistics
+        if np.any(enhanced_mask != foreground_np):
+            added_pixels = np.sum(enhanced_mask) - np.sum(foreground_np)
+            # print(f"🔧 Region propfill added {added_pixels} pixels to fill hollow regions")
+        #---------------------------------------------------------------------------------------------------------------------------------
+        # Heatmap accumulation
+        # pixelwise_alpha = alpha_start - (heatmap * (alpha_start - alpha_end))
+        # pixelwise_alpha = torch.clamp(pixelwise_alpha, min=alpha_end)
+    
+        # heatmap = torch.where(
+        #     filled_mask & table_mask_tensor,
+        #     torch.clamp(heatmap + pixelwise_alpha, 0, 1),
+        #     heatmap
+        # )
+
+        if heatmap is None:
+            heatmap = torch.zeros((working_H, working_W), dtype=torch.float32, device=device)
+            
+        pixelwise_alpha = alpha_start - (heatmap * (alpha_start - alpha_end))
+        pixelwise_alpha = torch.clamp(pixelwise_alpha, min=alpha_end)
+        
+        # === ACCUMULATION: Grow heatmap slowly where foreground detected ===
+        heatmap = torch.where(
+            filled_mask & table_mask_tensor,
+            torch.clamp(heatmap + pixelwise_alpha * 0.3, 0, 1),  # 0.3 factor = SLOW growth
+            heatmap
+        )
+        if cleaning_mask is not None:
+            # Convert cleaning mask to tensor
+            cleaning_tensor = torch.from_numpy(cleaning_mask > 0).bool().to(device)
+            
+            # Ensure dimensions match
+            if cleaning_tensor.shape != heatmap.shape:
+                # This shouldn't happen, but safety check
+                pass
+            
+            # Calculate decay rate (slower for older/hotter areas)
+            decay_alpha = alpha_start - (heatmap * (alpha_start - alpha_end))
+            decay_alpha = torch.clamp(decay_alpha, min=alpha_end)
+            
+            # Apply gradual decay where cleaning
+            heatmap = torch.where(
+                cleaning_tensor & table_mask_tensor,
+                torch.clamp(heatmap - decay_alpha * 0.8, 0, 1),  # 0.8 = decay slightly faster than growth
+                heatmap
+            )
+        # === CRITICAL: Proper output resizing ===
+        heatmap_np = heatmap.detach().cpu().numpy()
+        
+        if needs_resize:
+            # Resize results back to original dimensions
+            # Use high-quality interpolation for final output
+            result_img = cv.resize(img_tensor.detach().cpu().numpy(), (orig_W, orig_H), 
+                                  interpolation=cv.INTER_LINEAR)
+            
+            # For heatmap, use INTER_LINEAR to preserve smooth gradients
+            heatmap_np = cv.resize(heatmap_np, (orig_W, orig_H), interpolation=cv.INTER_LINEAR)
+            
+            # Resize table mask back for final masking
+            if table_mask is not None:
+                table_mask_final = cv.resize(table_mask_tensor.detach().cpu().numpy().astype(np.uint8), 
+                                           (orig_W, orig_H), interpolation=cv.INTER_NEAREST) > 0
+                heatmap_np = heatmap_np * table_mask_final
+            
+            # Use original image for blending
+            result = img.copy()
+        else:
+            result_img = img_tensor.detach().cpu().numpy()
+            result = img.copy()
+            
+            if table_mask is not None:
+                table_mask_np = table_mask_tensor.detach().cpu().numpy()
+                heatmap_np = heatmap_np * table_mask_np
+    
+        # Visualization with proper blending
+        # heatmap_viz = cv.applyColorMap((heatmap_np * 255).astype(np.uint8), cv.COLORMAP_JET)
+        # significant_heat = (heatmap_np > 0.1)
+    
+        # if np.any(significant_heat):
+        #     img_region = result[significant_heat]
+        #     heat_region = heatmap_viz[significant_heat]
+    
+        #     if img_region.size > 0 and heat_region.size > 0:
+        #         blended = cv.addWeighted(img_region, 0.7, heat_region, 0.3, 0)
+        #         result[significant_heat] = blended
+    
+        # return result, heatmap_np
+        # === FIX: Ensure heatmap stays ONLY within table bounds ===
+        if table_mask is not None:
+            # Match dimensions
+            if table_mask.shape != heatmap_np.shape:
+                table_mask_resized = cv.resize(
+                    table_mask.astype(np.uint8), 
+                    (heatmap_np.shape[1], heatmap_np.shape[0]), 
+                    interpolation=cv.INTER_NEAREST
+                )
+                table_mask_final = table_mask_resized > 0
+            else:
+                table_mask_final = table_mask > 0
+            
+            # CRITICAL: Zero out heatmap completely outside table
+            heatmap_np = heatmap_np * table_mask_final.astype(np.float32)
+        else:
+            table_mask_final = np.ones(heatmap_np.shape, dtype=bool)
+        
+        # Create visualization ONLY on table area (no blue background)
+        heatmap_colored = cv.applyColorMap(
+            (heatmap_np * 255).astype(np.uint8), 
+            cv.COLORMAP_JET
+        )
+        
+        # Apply transparency: only blend where heatmap > threshold AND inside table
+        significant_heat = (heatmap_np > 0.1) & table_mask_final
+        
+        if np.any(significant_heat):
+            # Blend ONLY significant areas
+            result_blended = result.copy()
+            result_blended[significant_heat] = cv.addWeighted(
+                result[significant_heat], 0.7, 
+                heatmap_colored[significant_heat], 0.3, 0
+            )
+            result = result_blended
+        
+        return result, heatmap_np

app_s_a_LiveCam.py

@@ -0,0 +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__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,29 @@
+opencv-python
+opencv-contrib-python
+joblib
+scikit-learn
+numpy==1.24.3
+#torchvision==0.15.2
+ultralytics
+gradio
+Pillow
+matplotlib==3.7.2
+pathlib
+python-dateutil==2.8.2
+
+# Additional dependencies
+pyyaml>=6.0
+requests>=2.31.0
+scipy>=1.11.0
+pandas>=2.0.3
+tqdm>=4.65.0
+seaborn>=0.12.2
+
+# For better video codec support
+imageio
+imageio-ffmpeg
+
+# System utilities
+psutil>=5.9.0
+plotly
+torch

send_discord.py

@@ -0,0 +1,172 @@
+import requests
+import cv2
+import numpy as np
+from datetime import datetime
+from pathlib import Path
+import logging
+import base64
+import io
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class DiscordAlertManager:
+    """Manages Discord webhook alerts for hygiene violations."""
+    
+    def __init__(self, discord_config: dict):
+        """
+        discord_config: {
+            'webhook_url': 'your_webhook_url'
+        }
+        """
+        self.webhook_url = discord_config['webhook_url']
+        self.alert_cooldown = 300
+        self.last_alert_time = None
+        self.dirty_start_time = None
+        self.dirty_threshold_seconds = 10
+        self.dirty_coverage_threshold = 0.06
+        
+    def should_send_alert(self, dirty_coverage: float, current_time: datetime) -> bool:
+        """Same logic as before"""
+        if dirty_coverage < self.dirty_coverage_threshold:
+            self.dirty_start_time = None
+            return False
+        
+        if self.dirty_start_time is None:
+            self.dirty_start_time = current_time
+            return False
+        
+        dirty_duration = (current_time - self.dirty_start_time).total_seconds()
+        if dirty_duration < self.dirty_threshold_seconds:
+            return False
+        
+        if self.last_alert_time is not None:
+            time_since_last = (current_time - self.last_alert_time).total_seconds()
+            if time_since_last < self.alert_cooldown:
+                return False
+        
+        return True
+    
+    def generate_heatmap_image(self, frame: np.ndarray, gmm_heatmap: np.ndarray, 
+                              output_path: str) -> str:
+        """Generate heatmap visualization"""
+        result = frame.copy()
+        height, width = result.shape[:2]
+        
+        if gmm_heatmap.shape != (height, width):
+            heatmap_resized = cv2.resize(gmm_heatmap, (width, height))
+        else:
+            heatmap_resized = gmm_heatmap
+        
+        heatmap_colored = cv2.applyColorMap(
+            (heatmap_resized * 255).astype(np.uint8),
+            cv2.COLORMAP_JET
+        )
+        
+        alpha = 0.5
+        result = cv2.addWeighted(frame, 1 - alpha, heatmap_colored, alpha, 0)
+        
+        # Add info panel
+        avg_dirt = np.mean(heatmap_resized)
+        max_dirt = np.max(heatmap_resized)
+        dirty_pixels = np.sum(heatmap_resized > 0.60)
+        coverage_percent = (dirty_pixels / heatmap_resized.size) * 100
+        
+        cv2.rectangle(result, (10, 10), (400, 120), (0, 0, 0), -1)
+        cv2.rectangle(result, (10, 10), (400, 120), (255, 255, 255), 2)
+        
+        info_text = [
+            f"Average Dirt: {avg_dirt:.2f}",
+            f"Maximum Dirt: {max_dirt:.2f}",
+            f"Red Zone: {coverage_percent:.1f}%",
+            f"Time: {datetime.now().strftime('%H:%M:%S')}"
+        ]
+        
+        for i, text in enumerate(info_text):
+            cv2.putText(result, text, (20, 35 + i * 25),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1)
+        
+        cv2.imwrite(output_path, result)
+        return output_path
+    
+    def send_alert(self, camera_name: str, dirty_coverage: float, 
+              dirty_duration: int, frame: np.ndarray, 
+              gmm_heatmap: np.ndarray) -> bool:
+        """Send Discord webhook alert with embedded image"""
+        try:
+            # Generate image
+            temp_image_path = f"tmp/heatmap_{datetime.now().timestamp()}.png"
+            self.generate_heatmap_image(frame, gmm_heatmap, temp_image_path)
+            
+            # Calculate duration
+            duration_mins = dirty_duration // 60
+            duration_secs = dirty_duration % 60
+            
+            # Create rich embed
+            embed = {
+                "title": "🚨 CLEANING ALERT",
+                "description": f"**{camera_name}** requires immediate attention!",
+                "color": 15158332,  # Red color (#E74C3C)
+                "fields": [
+                    {
+                        "name": "📍 Location",
+                        "value": camera_name,
+                        "inline": True
+                    },
+                    {
+                        "name": "🔴 Coverage",
+                        "value": f"{dirty_coverage*100:.1f}%",
+                        "inline": True
+                    },
+                    {
+                        "name": "⏱ Duration",
+                        "value": f"{duration_mins}m {duration_secs}s",
+                        "inline": True
+                    },
+                    {
+                        "name": "⚠️ Action Required",
+                        "value": "Table has exceeded cleanliness threshold and needs cleaning.",
+                        "inline": False
+                    }
+                ],
+                "footer": {
+                    "text": "Kitchen Hygiene Monitoring System"
+                },
+                "timestamp": datetime.utcnow().isoformat()
+            }
+            
+            # Prepare webhook payload with embeds
+            payload = {
+                "username": "Hygiene Monitor Bot",
+                "avatar_url": "https://cdn-icons-png.flaticon.com/512/3699/3699516.png",
+                "embeds": [embed]
+            }
+            
+            # Read the image file
+            with open(temp_image_path, 'rb') as f:
+                image_data = f.read()
+            
+            # Prepare the multipart form data
+            files = {
+                'payload_json': (None, json.dumps(payload), 'application/json'),
+                'file': ('heatmap.png', image_data, 'image/png')
+            }
+            
+            # Send the request
+            response = requests.post(self.webhook_url, files=files)
+            
+            if response.status_code in [200, 204]:
+                self.last_alert_time = datetime.now()
+                logger.info(f"✅ Discord alert sent for {camera_name}")
+                Path(temp_image_path).unlink(missing_ok=True)
+                return True
+            else:
+                logger.error(f"Discord webhook error: {response.status_code} - {response.text}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Failed to send Discord alert: {str(e)}")
+            import traceback
+            logger.error(traceback.format_exc())
+            return False