matrice-analytics 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

matrice_analytics/post_processing/usecases/color_detection.py

@@ -78,11 +78,12 @@ class ColorDetectionConfig(BaseConfig):
     alert_config: Optional[AlertConfig] = None
     time_window_minutes: int = 60
     enable_unique_counting: bool = True
-    enable_smoothing: bool = True
+    enable_smoothing: bool = False
     smoothing_algorithm: str = "observability"
     smoothing_window_size: int = 20
     smoothing_cooldown_frames: int = 5
     smoothing_confidence_range_factor: float = 0.5
+    detector = True
 
     #JBK_720_GATE POLYGON = [[86, 328], [844, 317], [1277, 520], [1273, 707], [125, 713]]
     zone_config: Optional[Dict[str, List[List[float]]]] = field(
@@ -92,7 +93,7 @@ class ColorDetectionConfig(BaseConfig):
         }
     }
 )
-    true_import: bool = False
+    # true_import: bool = False
 
     def validate(self) -> List[str]:
         errors = super().validate()
@@ -112,6 +113,16 @@ class ColorDetectionConfig(BaseConfig):
             errors.append("smoothing_confidence_range_factor must be positive")
         return errors
     
+    def __post_init__(self):
+        # Lazy initialization: the ClipProcessor will be created once by the use case
+        # to avoid repeated model downloads and to ensure GPU session reuse.
+        if self.detector:
+            self.detector = ClipProcessor()
+            print("ClipProcessor Loaded Successfully!!") 
+        else:
+            print("Clip color detector disabled by config")
+            self.detector = None
+    
 
 
 class ColorDetectionUseCase(BaseProcessor):
@@ -124,32 +135,32 @@ class ColorDetectionUseCase(BaseProcessor):
         "three wheelers -CNG-": "Three Wheelers (CNG)", "human hauler": "Human Hauler",
         "van": "Van", "wheelbarrow": "Wheelbarrow"
     }
-    
+
     def __init__(self):
         super().__init__("color_detection")
         self.category = "visual_appearance"
-        
+
         self.target_categories = ["car", "bicycle", "bus", "motorcycle"]
-        
+
         self.CASE_TYPE: Optional[str] = 'color_detection'
         self.CASE_VERSION: Optional[str] = '1.3'
-        
+
         self.tracker = None  # AdvancedTracker instance
         self.smoothing_tracker = None  # BBoxSmoothingTracker instance
         self._total_frame_counter = 0  # Total frames processed
         self._global_frame_offset = 0  # Frame offset for new sessions
         self._color_total_track_ids = defaultdict(set)  # Cumulative track IDs per category-color
         self._color_current_frame_track_ids = defaultdict(set)  # Per-frame track IDs per category-color
-        
+
         self._tracking_start_time = None
-        
+
         self._track_aliases: Dict[Any, Any] = {}
         self._canonical_tracks: Dict[Any, Dict[str, Any]] = {}
         # Tunable parameters – adjust if necessary for specific scenarios
         self._track_merge_iou_threshold: float = 0.05  # IoU ≥ 0.05 →
         self._track_merge_time_window: float = 7.0  # seconds within which to merge
 
-        self._ascending_alert_list: List[int] = []  
+        self._ascending_alert_list: List[int] = []
         self.current_incident_end_timestamp: str = "N/A"
         self.color_det_dict = {}
         self.start_timer = None
@@ -158,12 +169,17 @@ class ColorDetectionUseCase(BaseProcessor):
         self._zone_total_track_ids = {}  # zone_name -> set of all track IDs that have been in zone
         self._zone_current_counts = {}  # zone_name -> current count in zone
         self._zone_total_counts = {}  # zone_name -> total count that have been in zone
-        self.logger.info("Initialized ColorDetectionUseCase with zone tracking")
-        self.detector = None #ClipProcessor()
+        self.logger.info("Initialized ColorDetectionUseCase with tracking")
+        #self.detector = None
         self.all_color_data = {}
         self.all_color_counts = {}
+        self.total_category_count = {}
+        self.category_color = {}
+        self.vehicle_tracks = {}
+        self.vehicle_stats = defaultdict(lambda: defaultdict(int))
+        self.zone_vehicle_stats = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))
         #self.jpeg = TurboJPEG()
-        
+        # data, config, ProcessingContext(), stream_info,input_bytes
     def process(
         self,
         data: Any, 
@@ -173,8 +189,10 @@ class ColorDetectionUseCase(BaseProcessor):
         stream_info: Optional[Dict[str, Any]] = None
     ) -> ProcessingResult:
         processing_start = time.time()
-        
+
         try:
+            cwd = os.getcwd()
+            print("Current working directory:", cwd)
             if not isinstance(config, ColorDetectionConfig):
                 return self.create_error_result(
                     "Invalid configuration type for color detection",
@@ -182,17 +200,17 @@ class ColorDetectionUseCase(BaseProcessor):
                     category=self.category,
                     context=context
                 )
-            
-            if config.true_import and self.detector is None:
-                self.detector = ClipProcessor()
-                self.logger.info("Initialized ClipProcessor for color detection")
+
+            # if config.true_import and self.detector is None:
+            #     self.detector = ClipProcessor()
+            #     self.logger.info("Initialized ClipProcessor for color detection")
 
             if context is None:
                 context = ProcessingContext()
-            
+
             if not input_bytes:
                 print("input_bytes is required for color detection")
-            
+
             if not data:
                 #print("data",data)
                 print("Detection data is required for color detection")
@@ -201,23 +219,17 @@ class ColorDetectionUseCase(BaseProcessor):
             context.input_format = input_format
             context.confidence_threshold = config.confidence_threshold
 
-            
             self.logger.info(f"Processing color detection with format: {input_format.value}")
-            
+
             # Step 1: Apply confidence filtering
             processed_data = filter_by_confidence(data, config.confidence_threshold)
-            #self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
-            
+
             # Step 2: Apply category mapping if provided
             if config.index_to_category:
-                processed_data = apply_category_mapping(processed_data, config.index_to_category)
-                #self.logger.debug("Applied category mapping")
+                color_processed_data = apply_category_mapping(processed_data, config.index_to_category)
 
-            if config.target_categories:
-                color_processed_data = [d for d in processed_data if d.get('category') in self.target_categories]
-                self.logger.debug("Applied category filtering")
+            color_processed_data = [d for d in color_processed_data if d['category'] in self.target_categories]
 
-            
             raw_processed_data = [copy.deepcopy(det) for det in color_processed_data]
             # Step 3: Apply bounding box smoothing if enabled
             if config.enable_smoothing:
@@ -232,26 +244,26 @@ class ColorDetectionUseCase(BaseProcessor):
                     )
                     self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
                 color_processed_data = bbox_smoothing(color_processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
-            
+
             # Step 4: Apply advanced tracking
             try:
                 from ..advanced_tracker import AdvancedTracker
                 from ..advanced_tracker.config import TrackerConfig
-                
+
                 if self.tracker is None:
                     tracker_config = TrackerConfig()
                     self.tracker = AdvancedTracker(tracker_config)
                     self.logger.info("Initialized AdvancedTracker for color detection tracking")
-                
+
                 color_processed_data = self.tracker.update(color_processed_data)
-            
+
             except Exception as e:
                 self.logger.warning(f"AdvancedTracker failed: {e}")
-            
+
 
             color_processed_data = self._attach_masks_to_detections(color_processed_data, raw_processed_data)
             self._total_frame_counter += 1
-            
+
             frame_number = None
             if stream_info:
                 input_settings = stream_info.get("input_settings", {})
@@ -260,19 +272,55 @@ class ColorDetectionUseCase(BaseProcessor):
                 # If start and end frame are the same, it's a single frame
                 if start_frame is not None and end_frame is not None and start_frame == end_frame:
                     frame_number = start_frame
-            
+
             # Step 7: Analyze colors in media
             color_analysis = self._analyze_colors_in_media(
-                color_processed_data, 
-                input_bytes, 
+                color_processed_data,
+                input_bytes,
                 config
             )
+            if config.zone_config:
+                color_processed_data = self._is_in_zone_robust(color_processed_data,config.zone_config)
+            print(color_processed_data)
+            try:
+                print("About to call process_color_in_frame...")
+
+                if config.detector is None:
+                    print("ERROR: Detector is None after initialization attempt!")
+                    curr_frame_color = {}
+
+                # else:
+                  # if color_processed_data:
+                  #   t_id = color_processed_data[0].get('track_id')
+                  #   if t_id is not None and t_id not in self.all_color_data:
+                  #       # curr_frame_color = {}
+                  #       curr_frame_color = config.detector.process_color_in_frame(color_processed_data,input_bytes,config.zone_config,stream_info)
+                  #       res_dict[curr_frame_color[t_id]['color']] = curr_frame_color[t_id]['confidence']
+                  #   else:
+                  #       curr_frame_color = {}
+                  #   print("process_color_in_frame completed successfully")
+                  # else:
+                  #   curr_frame_color = {}
+
+                #------------------------ORiginal Code to run on all frames-----------------------
+                else:
+                    print(len(color_processed_data))
+                    curr_frame_color = config.detector.process_color_in_frame(
+                        color_processed_data,
+                        input_bytes,
+                        config.zone_config,
+                        stream_info,
+                    )
+                    print("process_color_in_frame completed successfully")
+            except Exception as e:
+                print(f"ERROR in process_color_in_frame: {e}")
+                import traceback
+                traceback.print_exc()
+                curr_frame_color = {}
 
-            curr_frame_color = self.detector.process_color_in_frame(color_processed_data,input_bytes,config.zone_config)
-            
-            # Step 8: Update color tracking state
+            self.update_vehicle_stats(curr_frame_color)
             self._update_color_tracking_state_from_analysis(color_analysis)
-            
+
             # Step 9: Calculate summaries
             color_summary = self._calculate_color_summary(color_analysis, config)
             totals = self.get_total_color_counts()
@@ -284,14 +332,16 @@ class ColorDetectionUseCase(BaseProcessor):
                     if color and tid is not None:
                         tmp[color].add(tid)
                 totals = {color: len(ids) for color, ids in tmp.items()}
-            total_category_counts = self.get_total_category_counts()
+            total_category_counts = self.get_total_category_counts(color_processed_data)
             color_summary['total_color_counts'] = totals
             color_summary['total_category_counts'] = total_category_counts
 
             general_summary = self._calculate_general_summary(processed_data, config)
-            
+            new_color_summary = self.merge_color_summary(color_processed_data,curr_frame_color)
+
             # Step 10: Zone analysis
-            
+            self.color_helper(curr_frame_color)
+
             zone_analysis = {}
             if config.zone_config and config.zone_config['zones']:
                 frame_data = color_processed_data
@@ -302,19 +352,19 @@ class ColorDetectionUseCase(BaseProcessor):
                         zone_analysis[zone_name] = enhanced_data
 
 
-            
+
             # Step 11: Generate alerts, incidents, tracking stats, and summary
             alerts = self._check_alerts(color_summary, frame_number, config)
 
             incidents_list = self._generate_incidents(color_summary, alerts, config, frame_number, stream_info)
             incidents_list = []
 
-            tracking_stats_list = self._generate_tracking_stats(color_summary, alerts, config, frame_number, stream_info, curr_frame_color)
+            tracking_stats_list = self._generate_tracking_stats(new_color_summary,color_summary, alerts, config,curr_frame_color, frame_number, stream_info)
 
             business_analytics_list = []
             summary_list = self._generate_summary(color_summary, incidents_list, tracking_stats_list, business_analytics_list, alerts)
 
-            
+
             incidents = incidents_list[0] if incidents_list else {}
             tracking_stats = tracking_stats_list[0] if tracking_stats_list else {}
             business_analytics = business_analytics_list[0] if business_analytics_list else {}
@@ -327,7 +377,7 @@ class ColorDetectionUseCase(BaseProcessor):
                 "zone_analysis": zone_analysis,
                 "human_text": summary}
             }
-        
+
             context.mark_completed()
 
             # Build result object following the new pattern
@@ -341,23 +391,168 @@ class ColorDetectionUseCase(BaseProcessor):
             proc_time = time.time() - processing_start
             processing_latency_ms = proc_time * 1000.0
             processing_fps = (1.0 / proc_time) if proc_time > 0 else None
-            # Log the performance metrics using the module-level logger
             print("latency in ms:",processing_latency_ms,"| Throughput fps:",processing_fps,"| Frame_Number:",self._total_frame_counter)
             return result
-            
+
         except Exception as e:
             self.logger.error(f"Color detection failed: {str(e)}", exc_info=True)
             if context:
                 context.mark_completed()
             return self.create_error_result(
-                str(e), 
+                str(e),
                 type(e).__name__,
                 usecase=self.name,
                 category=self.category,
                 context=context
             )
-    
+
+    def update_vehicle_stats(self, frame_detections: dict):
+        """
+        Update global vehicle statistics ensuring uniqueness per track_id and per zone.
+        If the same vehicle (track_id) is seen again:
+            - Ignore if confidence is lower.
+            - Update its color if confidence is higher.
+        """
+
+        # Ensure zone-level data structures exist
+        if not hasattr(self, "zone_vehicle_stats"):
+            self.zone_vehicle_stats = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))
+
+        for _, det in frame_detections.items():
+            track_id = det.get('track_id')
+            if track_id is None:
+                continue
+
+            vehicle_type = det.get('object_label', 'unknown').lower()
+            color = det.get('color', 'unknown').lower()
+            conf = det.get('confidence', 0.0)
+            zone = det.get('zone_name', 'Unknown_Zone')
+
+            # If this track_id is new → add and count
+            if track_id not in self.vehicle_tracks:
+                self.vehicle_tracks[track_id] = {
+                    'object_label': vehicle_type,
+                    'color': color,
+                    'confidence': conf,
+                    'zone': zone
+                }
+                self.vehicle_stats[vehicle_type][color] += 1
+                self.zone_vehicle_stats[zone][vehicle_type][color] += 1
+
+            else:
+                existing = self.vehicle_tracks[track_id]
+                if conf > existing['confidence']:
+                    old_color = existing['color']
+                    old_zone = existing.get('zone', zone)
+                    old_type = existing.get('object_label', vehicle_type)
+
+                    # Decrease old counts
+                    self.vehicle_stats[old_type][old_color] -= 1
+                    if self.vehicle_stats[old_type][old_color] <= 0:
+                        del self.vehicle_stats[old_type][old_color]
+
+                    self.zone_vehicle_stats[old_zone][old_type][old_color] -= 1
+                    if self.zone_vehicle_stats[old_zone][old_type][old_color] <= 0:
+                        del self.zone_vehicle_stats[old_zone][old_type][old_color]
+
+                    # Update track info
+                    self.vehicle_tracks[track_id].update({
+                        'color': color,
+                        'confidence': conf,
+                        'zone': zone,
+                    })
+
+                    # Increase new counts
+                    self.vehicle_stats[vehicle_type][color] += 1
+                    self.zone_vehicle_stats[zone][vehicle_type][color] += 1
+
+
+    def merge_color_summary(self,detections_data: List[Dict[str, Any]], curr_frame_color: Dict[int, Dict[str, Any]]) -> Dict[str, Any]:
+          """
+          Combine base detections with current frame color information and produce a color summary.
+          Returns structure similar to _calculate_color_summary().
+          """
+
+          category_colors = defaultdict(lambda: defaultdict(int))
+          detections = []
+          counts = {}
+
+          # Merge detections with color info
+          for record in detections_data:
+              track_id = record.get("track_id")
+              category = record.get("category", "unknown")
+              conf = record.get("confidence", 0.0)
+              bbox = record.get("bounding_box", {})
+              frame_id = record.get("frame_id")
+              zone_name = record.get("zone_name", "Unknown")
+
+              # Get color from curr_frame_color
+              main_color = "unknown"
+              if track_id in curr_frame_color:
+                  main_color = curr_frame_color[track_id].get("color", "unknown")
+
+              category_colors[category][main_color] += 1
+              counts[category] = counts.get(category, 0) + 1
+
+              detections.append({
+                  "bounding_box": bbox,
+                  "category": category,
+                  "confidence": conf,
+                  "track_id": track_id,
+                  "frame_id": frame_id,
+                  "main_color": main_color,
+                  "zone_name": zone_name
+              })
+
+          # Flatten color distribution
+          all_colors = defaultdict(int)
+          for category_data in category_colors.values():
+              for color, count in category_data.items():
+                  all_colors[color] += count
+
+          # Find dominant color per category
+          dominant_colors = {}
+          for category, colors in category_colors.items():
+              if colors:
+                  color, count = max(colors.items(), key=lambda x: x[1])
+                  dominant_colors[category] = {
+                      "color": color,
+                      "count": count,
+                      "percentage": round((count / sum(colors.values())) * 100, 1)
+                  }
+
+          # Final summary dict
+          summary = {
+              "total_count": sum(counts.values()),
+              "per_category_count": counts,
+              "detections": detections,
+              "color_distribution": dict(all_colors),
+              "dominant_colors": dominant_colors
+          }
+
+          return summary
+
+    def get_vehicle_stats(self):
+        """Return the current global vehicle statistics as a normal dictionary."""
+        return {vtype: dict(colors) for vtype, colors in self.vehicle_stats.items()}
+
+    def _is_in_zone_robust(self,detections,zones):
+        if not detections:
+          return {}
+        new_data = []
+        for det in detections:
+          bbox = det.get('bounding_box')
+          cx,cy = get_bbox_bottom25_center(bbox)
+          for zone, region in zones.items():
+            for reg, poly in region.items():
+              if point_in_polygon((cx,cy),poly):
+                det['zone_name'] = reg
+                new_data.append(det)
+        return new_data
+
     def color_helper(self, curr_data):
+        if curr_data is None:
+            return
         for tid, data in curr_data.items():
             if tid not in self.all_color_data:
                 # First time seeing this track
@@ -391,25 +586,16 @@ class ColorDetectionUseCase(BaseProcessor):
                     # update track info
                     self.all_color_data[tid]["color"] = new_color
                     self.all_color_data[tid]["confidence"] = data.get("confidence")
-
-
-
+        # return self.all_color_data
 
     def _analyze_colors_in_media(
-        self, 
-        data: Any, 
-        media_bytes: bytes, 
+        self,
+        data: Any,
+        media_bytes: bytes,
         config: ColorDetectionConfig
     ) -> List[Dict[str, Any]]:
         """Analyze colors of detected objects in video frames or images."""
-        
-        # Determine if input is video or image
-        is_video = self._is_video_bytes(media_bytes)
-        
-        if is_video:
-            return self._analyze_colors_in_video(data, media_bytes, config)
-        else:
-            return self._analyze_colors_in_image(data, media_bytes, config)
+        return self._analyze_colors_in_image(data, media_bytes, config)
 
     def _update_color_tracking_state_from_analysis(self, color_analysis: List[Dict[str, Any]]) -> None:
         """Update total tracking store using analyzed color results.
@@ -422,7 +608,7 @@ class ColorDetectionUseCase(BaseProcessor):
             self._color_total_track_ids = existing_store
         # Reset current frame tracking for this frame
         self._color_current_frame_track_ids = defaultdict(set)
-        
+
         for rec in color_analysis:
             cat = rec.get('category')
             color = rec.get('main_color')
@@ -466,7 +652,7 @@ class ColorDetectionUseCase(BaseProcessor):
                     self._color_total_track_ids[key].add(track_id)
                     # Also update current frame tracking
                     self._color_current_frame_track_ids[key].add(track_id)
-    
+
     def _is_video_bytes(self, media_bytes: bytes) -> bool:
         """Determine if bytes represent a video file."""
         # Check common video file signatures
@@ -477,16 +663,16 @@ class ColorDetectionUseCase(BaseProcessor):
             b'\x1aE\xdf\xa3',  # MKV/WebM
             b'ftyp',  # General MP4 family
         ]
-        
+
         for signature in video_signatures:
             if media_bytes.startswith(signature) or signature in media_bytes[:50]:
                 return True
         return False
-    
+
     def _analyze_colors_in_video(
-        self, 
-        data: Any, 
-        video_bytes: bytes, 
+        self,
+        data: Any,
+        video_bytes: bytes,
         config: ColorDetectionConfig
     ) -> List[Dict[str, Any]]:
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_video:
@@ -574,22 +760,22 @@ class ColorDetectionUseCase(BaseProcessor):
                 os.unlink(video_path)
 
     def _analyze_colors_in_image(
-        self, 
-        data: Any, 
-        image_bytes: bytes, 
+        self,
+        data: Any,
+        image_bytes: bytes,
         config: ColorDetectionConfig
     ) -> List[Dict[str, Any]]:
         image_array = np.frombuffer(image_bytes, np.uint8)
         image = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
         #image = self.jpeg.decode(image_bytes, pixel_format=TJPF_RGB)
-        
+
         if image is None:
             raise RuntimeError("Failed to decode image from bytes")
-        
+
         rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
         color_analysis = []
         detections = self._get_frame_detections(data, "0")
-        
+
         for detection in detections:
             if detection.get("confidence", 1.0) < config.confidence_threshold:
                 continue
@@ -610,12 +796,14 @@ class ColorDetectionUseCase(BaseProcessor):
             if not in_any_zone:
                 continue  # Skip detections outside zones
 
-            crop = self._crop_bbox(rgb_image, bbox, config.bbox_format)
-            if crop.size == 0:
-                continue
+            # crop = self._crop_bbox(rgb_image, bbox, config.bbox_format)
+            # if crop.size == 0:
+            #     continue
 
-            major_colors = extract_major_colors(crop, k=config.top_k_colors)
-            main_color = major_colors[0][0] if major_colors else "unknown"
+            # major_colors = extract_major_colors(crop, k=config.top_k_colors)
+            # main_color = major_colors[0][0] if major_colors else "unknown"
+            main_color = "unknown"
+            major_colors = []
 
             color_record = {
                 "frame_id": "0",
@@ -630,10 +818,10 @@ class ColorDetectionUseCase(BaseProcessor):
                 "zone_name": zone_name
             }
             color_analysis.append(color_record)
-        
+
         return color_analysis
-        
-    
+
+
     def _get_frame_detections(self, data: Any, frame_key: str) -> List[Dict[str, Any]]:
         """Extract detections for a specific frame from data."""
         if isinstance(data, dict):
@@ -644,11 +832,11 @@ class ColorDetectionUseCase(BaseProcessor):
             return data
         else:
             return []
-                
+
     def _crop_bbox(self, image: np.ndarray, bbox: Dict[str, Any], bbox_format: str) -> np.ndarray:
         """Crop bounding box region from image."""
         h, w = image.shape[:2]
-        
+
         # Auto-detect bbox format
         if bbox_format == "auto":
             if "xmin" in bbox:
@@ -657,7 +845,7 @@ class ColorDetectionUseCase(BaseProcessor):
                 bbox_format = "x_y_width_height"
             else:
                 return np.zeros((0, 0, 3), dtype=np.uint8)
-                
+
         # Extract coordinates based on format
         if bbox_format == "xmin_ymin_xmax_ymax":
             xmin = max(0, int(bbox["xmin"]))
@@ -671,9 +859,9 @@ class ColorDetectionUseCase(BaseProcessor):
             ymax = min(h, int(bbox["y"] + bbox["height"]))
         else:
             return np.zeros((0, 0, 3), dtype=np.uint8)
-            
+
         return image[ymin:ymax, xmin:xmax]
-        
+
     def _calculate_color_summary(self, color_analysis: List[Dict], config: ColorDetectionConfig) -> Dict[str, Any]:
         category_colors = defaultdict(lambda: defaultdict(int))
         total_detections = len(color_analysis)
@@ -693,7 +881,7 @@ class ColorDetectionUseCase(BaseProcessor):
                 "main_color": record["main_color"]
             })
 
-            
+
         self.logger.debug(f"Valid detections after filtering: {len(detections)}")
         summary = {
             "total_count": sum(counts.values()),
@@ -725,14 +913,14 @@ class ColorDetectionUseCase(BaseProcessor):
 
 
         return summary
-        
+
     def _calculate_general_summary(self, processed_data: Any, config: ColorDetectionConfig) -> Dict[str, Any]:
         """Calculate general detection summary."""
-        
+
         # Count objects by category
         category_counts = defaultdict(int)
         total_objects = 0
-        
+
         if isinstance(processed_data, dict):
             # Frame-based format
             for frame_data in processed_data.values():
@@ -749,18 +937,18 @@ class ColorDetectionUseCase(BaseProcessor):
                     category = detection.get("category", "unknown")
                     category_counts[category] += 1
                     total_objects += 1
-                        
+
         return {
             "total_objects": total_objects,
             "category_counts": dict(category_counts),
             "categories_detected": list(category_counts.keys())
         }
-        
+
     def _calculate_metrics(self, color_analysis: List[Dict], color_summary: Dict, config: ColorDetectionConfig, context: ProcessingContext) -> Dict[str, Any]:
         """Calculate detailed metrics for analytics."""
         total_detections = len(color_analysis)
         unique_colors = len(color_summary.get("color_distribution", {}))
-        
+
         metrics = {
             "total_detections": total_detections,
             "unique_colors": unique_colors,
@@ -772,15 +960,15 @@ class ColorDetectionUseCase(BaseProcessor):
             "detection_rate": 0.0,
             "average_colors_per_detection": config.top_k_colors
         }
-        
+
         # Calculate color diversity
         if total_detections > 0:
             metrics["color_diversity"] = (unique_colors / total_detections) * 100
-        
+
         # Calculate detection rate
         if config.time_window_minutes and config.time_window_minutes > 0:
             metrics["detection_rate"] = (total_detections / config.time_window_minutes) * 60
-        
+
         # Per-category metrics
         if color_summary.get("categories"):
             category_metrics = {}
@@ -792,7 +980,7 @@ class ColorDetectionUseCase(BaseProcessor):
                     "color_diversity": (len(colors) / category_total) * 100 if category_total > 0 else 0
                 }
             metrics["category_metrics"] = category_metrics
-        
+
         # Processing settings
         metrics["processing_settings"] = {
             "confidence_threshold": config.confidence_threshold,
@@ -801,12 +989,12 @@ class ColorDetectionUseCase(BaseProcessor):
             "target_categories": config.target_categories,
             "enable_unique_counting": config.enable_unique_counting
         }
-        
+
         return metrics
-        
+
     def _extract_predictions(self, color_analysis: List[Dict], config: ColorDetectionConfig) -> List[Dict]:
         """Extract predictions in standard format."""
-        
+
         predictions = []
         for record in color_analysis:
             prediction = {
@@ -821,9 +1009,9 @@ class ColorDetectionUseCase(BaseProcessor):
             if "detection_id" in record:
                 prediction["id"] = record["detection_id"]
             predictions.append(prediction)
-            
+
         return predictions
-    
+
     def _generate_summary(self, summary: dict, incidents: List, tracking_stats: List, business_analytics: List, alerts: List) -> List[str]:
         """
         Generate a human_text string for the tracking_stat, incident, business analytics and alerts.
@@ -834,7 +1022,7 @@ class ColorDetectionUseCase(BaseProcessor):
         if len(incidents) > 0:
             lines.append("Incidents: "+f"\n\t{incidents[0].get('human_text', 'No incidents detected')}")
         if len(tracking_stats) > 0:
-            lines.append("Tracking Statistics: "+f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}")
+            lines.append(f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}")
         if len(business_analytics) > 0:
             lines.append("Business Analytics: "+f"\t{business_analytics[0].get('human_text', 'No business analytics detected')}")
 
@@ -842,7 +1030,7 @@ class ColorDetectionUseCase(BaseProcessor):
             lines.append("Summary: "+"No Summary Data")
 
         return ["\n".join(lines)]
-    
+
     def _generate_events(self, color_summary: Dict, alerts: List, config: ColorDetectionConfig, frame_number: Optional[int] = None) -> List[Dict]:
         """Generate structured events with frame-based keys."""
         frame_key = str(frame_number) if frame_number is not None else "current_frame"
@@ -906,15 +1094,17 @@ class ColorDetectionUseCase(BaseProcessor):
             frame_events.append(alert_event)
 
         return events
-    
+
     def _generate_tracking_stats(
             self,
+            new_color_summary: Dict,
             counting_summary: Dict,
             alerts: Any,
             config: ColorDetectionConfig,
+            curr_frame_color: Any,
+            total_color_data: Any,
             frame_number: Optional[int] = None,
             stream_info: Optional[Dict[str, Any]] = None,
-            curr_frame_color: Any = None
     ) -> List[Dict]:
         """Generate structured tracking stats for the output format with frame-based keys, including track_ids_info and detections with masks."""
         # frame_key = str(frame_number) if frame_number is not None else "current_frame"
@@ -925,7 +1115,7 @@ class ColorDetectionUseCase(BaseProcessor):
         total_detections = counting_summary.get("total_count", 0)
         total_color_counts_dict = counting_summary.get("total_color_counts", {})
         total_category_counts_dict = counting_summary.get("total_category_counts", {})
-        cumulative_total = sum(total_color_counts_dict.values()) if total_color_counts_dict else 0
+        # cumulative_total = sum(total_color_counts_dict.values()) if total_color_counts_dict else 0
         per_category_count = counting_summary.get("per_category_count", {})
 
         # Compute current color counts from detections
@@ -939,20 +1129,13 @@ class ColorDetectionUseCase(BaseProcessor):
 
         current_timestamp = self._get_current_timestamp_str(stream_info, precision=False)
         start_timestamp = self._get_start_timestamp_str(stream_info, precision=False)
-        
+
         # Create high precision timestamps for input_timestamp and reset_timestamp
         high_precision_start_timestamp = self._get_current_timestamp_str(stream_info, precision=True)
         high_precision_reset_timestamp = self._get_start_timestamp_str(stream_info, precision=True)
 
         camera_info = self.get_camera_info_from_stream(stream_info)
-        total_color_data = self.color_helper(curr_frame_color)
-        print("========================CURR FRAME=======================")
-        print(curr_frame_color)
-        print("========================CURR FRAME=======================")
-
-        print("========================TOTAL=======================")
-        print(total_color_data)
-        print("========================TOTAL=======================")
+        # total_color_data = self.color_helper(curr_frame_color)
 
         human_text_lines = []
         color_counts = {}
@@ -963,51 +1146,72 @@ class ColorDetectionUseCase(BaseProcessor):
                 if color not in color_counts:
                     color_counts[color] = 0
                 color_counts[color] += 1
+        zone_frame_data = {}
+        if curr_frame_color:
+            for tid, data in curr_frame_color.items():
+                zone = data.get("zone_name", "Unknown_Zone")
+                color = data.get("color", "unknown")
+                category = data.get("object_label", "unknown")
+
+                if zone not in zone_frame_data:
+                    zone_frame_data[zone] = {
+                        "color_counts": {},
+                        "category_counts": {}
+                    }
 
-        # After processing all frames, print the final counts
-        print("Unique color counts:", color_counts)
+                # Count colors
+                zone_frame_data[zone]["color_counts"][color] = (
+                    zone_frame_data[zone]["color_counts"].get(color, 0) + 1
+                )
 
+                # Count vehicle types
+                zone_frame_data[zone]["category_counts"][category] = (
+                    zone_frame_data[zone]["category_counts"].get(category, 0) + 1
+                )
 
         # CURRENT FRAME section
         human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
-        if total_detections > 0:
-            # Vehicle categories (current frame)
-            category_counts = [f"{count} {cat}" for cat, count in per_category_count.items()]
-            if len(category_counts) == 1:
-                detection_text = category_counts[0] + " detected"
-            elif len(category_counts) == 2:
-                detection_text = f"{category_counts[0]} and {category_counts[1]} detected"
-            else:
-                detection_text = f"{', '.join(category_counts[:-1])}, and {category_counts[-1]} detected"
-            human_text_lines.append(f"\t- {detection_text}")
-
-            # Colors (current frame)
-            if color_counts:
-                color_counts_text = ", ".join([f"{count} {color}" for color, count in color_counts.items()])
-                human_text_lines.append(f"\t- Colors: {color_counts_text}")
-        else:
+        if not curr_frame_color or total_detections == 0:
             human_text_lines.append(f"\t- No detections")
+        else:
+            for zone_name, stats in zone_frame_data.items():
+                color_counts = stats["color_counts"]
+                per_category_count = stats["category_counts"]
+                if config.zone_config:
+                    human_text_lines.append(f"\t{zone_name}:")
+                if per_category_count:
+                    category_counts = [f"{count} {cat}" for cat, count in per_category_count.items()]
+                    if len(category_counts) == 1:
+                        detection_text = category_counts[0] + " detected"
+                    elif len(category_counts) == 2:
+                        detection_text = f"{category_counts[0]} and {category_counts[1]} detected"
+                    else:
+                        detection_text = f"{', '.join(category_counts[:-1])}, and {category_counts[-1]} detected"
+                    human_text_lines.append(f"\t\t- {detection_text}")
+
+                if color_counts:
+                    color_counts_text = ", ".join([f"{count} {color}" for color, count in color_counts.items()])
+                    human_text_lines.append(f"\t\t- Colors: {color_counts_text}")
 
         human_text_lines.append("")  # spacing
 
+        cumulative_total = sum(self.all_color_counts.values())
+        stats = self.zone_vehicle_stats
+
         # TOTAL SINCE section
         human_text_lines.append(f"TOTAL SINCE {start_timestamp}:")
-        human_text_lines.append(f"\t- Total Detected (by color): {cumulative_total}")
-        # Add category-wise totals
-        
-        if total_category_counts_dict:
-            human_text_lines.append("\t- Categories:")
-            for cat, count in total_category_counts_dict.items():
-                if count > 0:
-                    human_text_lines.append(f"\t\t- {cat}: {count}")
-        # Add color-wise totals
-        if total_color_data:
-            human_text_lines.append("\t- Colors:")
-            for color, count in total_color_data.items():
-                if count > 0:
-                    human_text_lines.append(f"\t\t- {color}: {count}")
-        # Build current_counts array in expected format  
-        # Build arrays
+        for zone_name, vehicles in stats.items():
+            total_in_zone = sum(sum(colors.values()) for colors in vehicles.values())
+            if config.zone_config:
+                human_text_lines.append(f"\t{zone_name}:")
+            human_text_lines.append(f"\t\t- Total Detected: {total_in_zone}")
+
+            for vehicle_type, colors in vehicles.items():
+                total_type_count = sum(colors.values())
+                human_text_lines.append(f"\t\t- {vehicle_type}: {total_type_count}")
+                for color, count in colors.items():
+                    human_text_lines.append(f"\t\t\t- {color}: {count}")
+
         current_counts_categories = []
         for cat, count in per_category_count.items():
             if count > 0 or total_detections > 0:
@@ -1030,9 +1234,9 @@ class ColorDetectionUseCase(BaseProcessor):
         # Include detections with masks from counting_summary
         # Prepare detections without confidence scores (as per eg.json)
         detections = []
-        for detection in counting_summary.get("detections", []):
+        for detection in new_color_summary.get("detections", []):
             bbox = detection.get("bounding_box", {})
-            category = detection.get("category", "person")
+            category = detection.get("main_color", "No_color")
             # Include segmentation if available (like in eg.json)
             if detection.get("masks"):
                 segmentation= detection.get("masks", [])
@@ -1077,68 +1281,16 @@ class ColorDetectionUseCase(BaseProcessor):
                 }
             ]
 
+
         # Keep backward-compat: put colors into total_counts and categories into current_counts
         tracking_stat=self.create_tracking_stats(total_counts=total_counts_colors, current_counts=current_counts_categories,
                             detections=detections, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
                             reset_settings=reset_settings, start_time=high_precision_start_timestamp ,
                             reset_time=high_precision_reset_timestamp)
 
-        # Add explicit breakdowns for consumers who want both types
-        # tracking_stat["current_category_counts"] = current_counts_categories
-        # tracking_stat["current_color_counts"] = current_counts_colors
-        # tracking_stat["total_category_counts"] = total_counts_categories
-        # tracking_stat["total_color_counts"] = total_counts_colors
-
         tracking_stats.append(tracking_stat)
         return tracking_stats
-    
-    def _generate_human_text_for_tracking(self, total_detections: int, color_summary: Dict, insights: List[str], summary: str, config: ColorDetectionConfig) -> str:
-        """Generate human-readable text for tracking stats."""
-        from datetime import datetime, timezone
-        
-        text_parts = [
-            #f"Tracking Start Time: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M')}",
-            #f"Objects Analyzed: {total_detections}"
-        ]
-        
-        if config.time_window_minutes:
-            detection_rate_per_hour = (total_detections / config.time_window_minutes) * 60
-            #text_parts.append(f"Detection Rate: {detection_rate_per_hour:.1f} objects per hour")
-        
-        # Add color statistics
-        unique_colors = len(color_summary.get("color_distribution", {}))
-        #text_parts.append(f"Unique Colors Detected: {unique_colors}")
-        
-        if total_detections > 0:
-            color_diversity = (unique_colors / total_detections) * 100
-            #text_parts.append(f"Color Diversity: {color_diversity:.1f}%")
-        
-        # Add category breakdown
-        categories = color_summary.get("categories", {})
-        if categories:
-            #text_parts.append(f"Categories Analyzed: {len(categories)}")
-            for category, colors in categories.items():
-                category_total = sum(colors.values())
-                if category_total > 0:
-                    dominant_color = max(colors.items(), key=lambda x: x[1])[0] if colors else "unknown"
-                    text_parts.append(f"  {category_total} {category.title()} detected, Color: {dominant_color}")
-        
-        # Add color distribution summary
-        color_distribution = color_summary.get("color_distribution", {})
-        if color_distribution:
-            top_colors = sorted(color_distribution.items(), key=lambda x: x[1], reverse=True)[:3]
-            #text_parts.append("Top Colors:")
-            for color, count in top_colors:
-                percentage = (count / total_detections) * 100
-                #text_parts.append(f"  {color.title()}: {count} objects ({percentage:.1f}%)")
-        
-        # Add key insights
-        # if insights:
-        #     text_parts.append("Key Color Insights:")
-        #     for insight in insights[:3]:  # Limit to first 3 insights
-        #         text_parts.append(f"  - {insight}")
-        
-        return "\n".join(text_parts)
+
 
     def reset_tracker(self) -> None:
         """Reset the advanced tracker instance."""
@@ -1222,7 +1374,7 @@ class ColorDetectionUseCase(BaseProcessor):
             filtered.append(detections[best_idx])
             used[best_idx] = True
         return filtered
-        
+
     def get_config_schema(self) -> Dict[str, Any]:
         """Get JSON schema for configuration validation."""
         return {
@@ -1242,7 +1394,7 @@ class ColorDetectionUseCase(BaseProcessor):
             "required": ["confidence_threshold", "top_k_colors"],
             "additionalProperties": False
         }
-        
+
     def create_default_config(self, **overrides) -> ColorDetectionConfig:
         """Create default configuration with optional overrides."""
         defaults = {
@@ -1261,7 +1413,7 @@ class ColorDetectionUseCase(BaseProcessor):
         }
         defaults.update(overrides)
         return ColorDetectionConfig(**defaults)
-    
+
     def _update_color_tracking_state(self, detections: List[Dict]):
         """Track unique track_ids per category and color for total count."""
         # Ensure storage is a defaultdict(set) to allow safe .add()
@@ -1298,20 +1450,19 @@ class ColorDetectionUseCase(BaseProcessor):
                 color_to_ids[color].update(ids)
         return {color: len(ids) for color, ids in color_to_ids.items()}
 
-    def get_total_category_counts(self):
+    def get_total_category_counts(self,data):
         """Return total unique track_id count per category (across all colors)."""
-        store = getattr(self, '_color_total_track_ids', {})
-        if not isinstance(store, dict):
-            return {}
-        category_to_ids = defaultdict(set)
-        for key, id_set in store.items():
-            if isinstance(key, str) and ':' in key:
-                cat, _ = key.split(':', 1)
-            else:
-                cat = key
-            ids = id_set if isinstance(id_set, set) else set(id_set or [])
-            category_to_ids[cat].update(ids)
-        return {cat: len(ids) for cat, ids in category_to_ids.items()}
+        for det in data:
+            track_id = det.get("track_id")
+            category = det.get("category")
+            if track_id and category:
+                if category not in self.total_category_count:
+                    self.total_category_count[category] = set()
+                self.total_category_count[category].add(track_id)
+
+        # Convert sets to counts
+        return {cat: len(track_ids) for cat, track_ids in self.total_category_count.items()}
+
 
     def _get_track_ids_info(self, detections: List[Dict]) -> Dict[str, Any]:
         """Get detailed information about track IDs for color detections (per frame)."""
@@ -1379,7 +1530,7 @@ class ColorDetectionUseCase(BaseProcessor):
                     det.setdefault("masks", ["EMPTY"])
 
             return processed_detections
-        
+
     def _generate_incidents(self, counting_summary: Dict, alerts: List, config: ColorDetectionConfig,
                         frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
         """Generate structured events for the output format with frame-based keys."""
@@ -1390,7 +1541,7 @@ class ColorDetectionUseCase(BaseProcessor):
         total_detections = counting_summary.get("total_count", 0)
         current_timestamp = self._get_current_timestamp_str(stream_info)
         camera_info = self.get_camera_info_from_stream(stream_info)
-        
+
         self._ascending_alert_list = self._ascending_alert_list[-900:] if len(self._ascending_alert_list) > 900 else self._ascending_alert_list
 
         if total_detections > 0:
@@ -1401,11 +1552,11 @@ class ColorDetectionUseCase(BaseProcessor):
             if start_timestamp and self.current_incident_end_timestamp=='N/A':
                 self.current_incident_end_timestamp = 'Incident still active'
             elif start_timestamp and self.current_incident_end_timestamp=='Incident still active':
-                if len(self._ascending_alert_list) >= 15 and sum(self._ascending_alert_list[-15:]) / 15 < 1.5: 
+                if len(self._ascending_alert_list) >= 15 and sum(self._ascending_alert_list[-15:]) / 15 < 1.5:
                     self.current_incident_end_timestamp = current_timestamp
             elif self.current_incident_end_timestamp!='Incident still active' and self.current_incident_end_timestamp!='N/A':
                 self.current_incident_end_timestamp = 'N/A'
-                
+
             if config.alert_config and hasattr(config.alert_config, 'count_thresholds') and config.alert_config.count_thresholds:
                 threshold = config.alert_config.count_thresholds.get("all", 15)
                 intensity = min(10.0, (total_detections / threshold) * 10)
@@ -1456,7 +1607,7 @@ class ColorDetectionUseCase(BaseProcessor):
                                         getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
                                 }
                 })
-        
+
             event= self.create_incident(incident_id=self.CASE_TYPE+'_'+str(frame_number), incident_type=self.CASE_TYPE,
                         severity_level=level, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
                         start_time=start_timestamp, end_time=self.current_incident_end_timestamp,
@@ -1468,7 +1619,7 @@ class ColorDetectionUseCase(BaseProcessor):
             incidents.append({})
 
         return incidents
-    
+
     def _check_alerts(self, summary: dict, frame_number:Any, config: ColorDetectionConfig) -> List[Dict]:
         """
         Check if any alert thresholds are exceeded and return alert dicts.
@@ -1510,7 +1661,7 @@ class ColorDetectionUseCase(BaseProcessor):
         if hasattr(config.alert_config, 'count_thresholds') and config.alert_config.count_thresholds:
 
             for category, threshold in config.alert_config.count_thresholds.items():
-                if category == "all" and total > threshold:  
+                if category == "all" and total > threshold:
 
                     alerts.append({
                         "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
@@ -1520,7 +1671,7 @@ class ColorDetectionUseCase(BaseProcessor):
                         "ascending": get_trend(self._ascending_alert_list, lookback=900, threshold=0.8),
                         "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
                                     getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
-                                }                    
+                                }
                     })
                 elif category in summary.get("per_category_count", {}):
                     count = summary.get("per_category_count", {})[category]
@@ -1533,12 +1684,17 @@ class ColorDetectionUseCase(BaseProcessor):
                             "ascending": get_trend(self._ascending_alert_list, lookback=900, threshold=0.8),
                             "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
                                     getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
-                                }       
+                                }
                         })
         else:
             pass
         return alerts
-    
+
+    def _format_timestamp_for_stream(self, timestamp: float) -> str:
+        """Format timestamp for streams (YYYY:MM:DD HH:MM:SS format)."""
+        dt = datetime.fromtimestamp(float(timestamp), tz=timezone.utc)
+        return dt.strftime('%Y:%m:%d %H:%M:%S')
+
     def _format_timestamp_for_video(self, timestamp: float) -> str:
         """Format timestamp for video chunks (HH:MM:SS.ms format)."""
         hours = int(timestamp // 3600)
@@ -1546,11 +1702,6 @@ class ColorDetectionUseCase(BaseProcessor):
         seconds = round(float(timestamp % 60),2)
         return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
 
-    def _format_timestamp_for_stream(self, timestamp: float) -> str:
-        """Format timestamp for streams (YYYY:MM:DD HH:MM:SS format)."""
-        dt = datetime.fromtimestamp(timestamp, tz=timezone.utc)
-        return dt.strftime('%Y:%m:%d %H:%M:%S')
-
     def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str]=None) -> str:
         """Get formatted current timestamp based on stream type."""
         
@@ -1564,6 +1715,7 @@ class ColorDetectionUseCase(BaseProcessor):
                     start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
                 stream_time_str = self._format_timestamp_for_video(start_time)
                 
+
                 return self._format_timestamp(stream_info.get("input_settings", {}).get("stream_time", "NA"))
             else:
                 return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
@@ -1575,8 +1727,7 @@ class ColorDetectionUseCase(BaseProcessor):
                 start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
 
             stream_time_str = self._format_timestamp_for_video(start_time)
-           
-
+            
             return self._format_timestamp(stream_info.get("input_settings", {}).get("stream_time", "NA"))
         else:
             stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
@@ -1595,22 +1746,22 @@ class ColorDetectionUseCase(BaseProcessor):
         """Get formatted start timestamp for 'TOTAL SINCE' based on stream type."""
         if not stream_info:
             return "00:00:00"
-        
+                
         if precision:
             if self.start_timer is None:
-                self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
+                self.start_timer = stream_info.get("input_settings", {}).get("stream_time", datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC"))
                 return self._format_timestamp(self.start_timer)
             elif stream_info.get("input_settings", {}).get("start_frame", "na") == 1:
-                self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
+                self.start_timer = stream_info.get("input_settings", {}).get("stream_time", datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC"))
                 return self._format_timestamp(self.start_timer)
             else:
                 return self._format_timestamp(self.start_timer)
 
         if self.start_timer is None:
-            self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
+            self.start_timer = stream_info.get("input_settings", {}).get("stream_time", datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC"))
             return self._format_timestamp(self.start_timer)
         elif stream_info.get("input_settings", {}).get("start_frame", "na") == 1:
-            self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
+            self.start_timer = stream_info.get("input_settings", {}).get("stream_time", datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC"))
             return self._format_timestamp(self.start_timer)
         
         else:
@@ -1632,7 +1783,7 @@ class ColorDetectionUseCase(BaseProcessor):
             dt = datetime.fromtimestamp(self._tracking_start_time, tz=timezone.utc)
             dt = dt.replace(minute=0, second=0, microsecond=0)
             return dt.strftime('%Y:%m:%d %H:%M:%S')
-    
+
     def _format_timestamp(self, timestamp: Any) -> str:
         """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
 
@@ -1693,37 +1844,37 @@ class ColorDetectionUseCase(BaseProcessor):
         """Update zone tracking with current frame data."""
         if not zone_analysis or not config.zone_config or not config.zone_config['zones']:
             return {}
-        
+
         enhanced_zone_analysis = {}
         zones = config.zone_config['zones']
-        
+
         # Initialize current frame zone tracks
         current_frame_zone_tracks = {zone_name: set() for zone_name in zones.keys()}
-        
+
         # Initialize zone tracking storage
         for zone_name in zones.keys():
             if zone_name not in self._zone_current_track_ids:
                 self._zone_current_track_ids[zone_name] = set()
             if zone_name not in self._zone_total_track_ids:
                 self._zone_total_track_ids[zone_name] = set()
-        
+
         # Check each detection against each zone
         for detection in detections:
             track_id = detection.get("track_id")
             if track_id is None:
                 continue
-            
+
             bbox = detection.get("bounding_box", detection.get("bbox"))
             if not bbox:
                 continue
-            
+
             # Check which zone this detection is in
             for zone_name, zone_polygon in zones.items():
                 if self._is_in_zone(bbox, zone_polygon):
                     current_frame_zone_tracks[zone_name].add(track_id)
                     if track_id not in self.color_det_dict:  # Use color_det_dict for consistency
                         self.color_det_dict[track_id] = [detection.get("main_color", "unknown"), detection.get("confidence", 0.0)]
-        
+
         # Update zone tracking for each zone
         for zone_name, zone_counts in zone_analysis.items():
             current_tracks = current_frame_zone_tracks.get(zone_name, set())
@@ -1731,7 +1882,7 @@ class ColorDetectionUseCase(BaseProcessor):
             self._zone_total_track_ids[zone_name].update(current_tracks)
             self._zone_current_counts[zone_name] = len(current_tracks)
             self._zone_total_counts[zone_name] = len(self._zone_total_track_ids[zone_name])
-            
+
             enhanced_zone_analysis[zone_name] = {
                 "current_count": self._zone_current_counts[zone_name],
                 "total_count": self._zone_total_counts[zone_name],
@@ -1739,7 +1890,7 @@ class ColorDetectionUseCase(BaseProcessor):
                 "total_track_ids": list(self._zone_total_track_ids[zone_name]),
                 "original_counts": zone_counts
             }
-        
+
         return enhanced_zone_analysis
 
     def _compute_iou(self, box1: Any, box2: Any) -> float: