Upload app.py

app.py

@@ -10,13 +10,12 @@ import os
 from dotenv import load_dotenv
 from collections import defaultdict
 import time
-from skimage.metrics import structural_similarity as ssim
 
 # Load environment variables
 load_dotenv()
 
 # Define API endpoint from environment variable
-API_URL = os.getenv("API_URL", "http://122.155.170.240:81")
+API_URL = os.getenv("API_URL", "http://localhost:8000")
 print(f"Using API URL: {API_URL}")
 DEFAULT_CONFIDENCE = float(os.getenv("DEFAULT_CONFIDENCE_THRESHOLD", "0.25"))
 
@@ -89,159 +88,12 @@ def calculate_movement(prev_center, curr_center, min_movement=10):
     except Exception as e:
         return False
 
-def extract_bbox_image(frame, bbox):
-    """Extract image region from bounding box"""
-    try:
-        if frame is None or len(bbox) != 4:
-            return None
-            
-        # Convert bbox to integers and ensure valid coordinates
-        x1, y1, x2, y2 = map(int, bbox)
-        
-        # Handle different bbox formats
-        if x2 < x1 or y2 < y1:  # If it's x,y,w,h format
-            x1, y1, w, h = bbox
-            x2, y2 = x1 + w, y1 + h
-            
-        # Ensure coordinates are within frame bounds
-        h, w = frame.shape[:2]
-        x1 = max(0, min(x1, w-1))
-        y1 = max(0, min(y1, h-1))
-        x2 = max(x1+1, min(x2, w))
-        y2 = max(y1+1, min(y2, h))
-        
-        # Extract region
-        bbox_img = frame[y1:y2, x1:x2]
-        
-        # Resize to standard size for comparison (64x64)
-        if bbox_img.size > 0:
-            bbox_img = cv2.resize(bbox_img, (64, 64))
-            return bbox_img
-        return None
-    except Exception as e:
-        return None
-
-def calculate_histogram_similarity(img1, img2):
-    """Calculate histogram-based similarity between two images"""
-    try:
-        if img1 is None or img2 is None:
-            return 0.0
-            
-        # Convert to HSV for better color comparison
-        hsv1 = cv2.cvtColor(img1, cv2.COLOR_BGR2HSV)
-        hsv2 = cv2.cvtColor(img2, cv2.COLOR_BGR2HSV)
-        
-        # Calculate histograms
-        hist1 = cv2.calcHist([hsv1], [0, 1, 2], None, [50, 60, 60], [0, 180, 0, 256, 0, 256])
-        hist2 = cv2.calcHist([hsv2], [0, 1, 2], None, [50, 60, 60], [0, 180, 0, 256, 0, 256])
-        
-        # Compare histograms using correlation
-        correlation = cv2.compareHist(hist1, hist2, cv2.HISTCMP_CORREL)
-        
-        # Normalize to 0-1 range
-        return max(0, correlation)
-    except Exception as e:
-        return 0.0
-
-def calculate_ssim_similarity(img1, img2):
-    """Calculate Structural Similarity Index (SSIM) between two images"""
-    try:
-        if img1 is None or img2 is None:
-            return 0.0
-            
-        # Convert to grayscale
-        gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
-        gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
-        
-        # Calculate SSIM
-        similarity_index = ssim(gray1, gray2)
-        
-        # Normalize to 0-1 range (SSIM can be negative)
-        return max(0, (similarity_index + 1) / 2)
-    except Exception as e:
-        return 0.0
-
-def calculate_feature_similarity(img1, img2):
-    """Calculate feature-based similarity using ORB features"""
-    try:
-        if img1 is None or img2 is None:
-            return 0.0
-            
-        # Convert to grayscale
-        gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
-        gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
-        
-        # Initialize ORB detector
-        orb = cv2.ORB_create(nfeatures=50)
-        
-        # Find keypoints and descriptors
-        kp1, des1 = orb.detectAndCompute(gray1, None)
-        kp2, des2 = orb.detectAndCompute(gray2, None)
-        
-        if des1 is None or des2 is None or len(des1) < 5 or len(des2) < 5:
-            return 0.0
-            
-        # Match features
-        bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
-        matches = bf.match(des1, des2)
-        
-        # Calculate similarity based on good matches
-        if len(matches) > 0:
-            # Sort matches by distance
-            matches = sorted(matches, key=lambda x: x.distance)
-            good_matches = [m for m in matches if m.distance < 50]  # Threshold for good matches
-            
-            # Similarity based on ratio of good matches
-            similarity = len(good_matches) / max(len(kp1), len(kp2))
-            return min(1.0, similarity)
-        
-        return 0.0
-    except Exception as e:
-        return 0.0
-
-def calculate_enhanced_bbox_similarity(bbox1, bbox2, frame1=None, frame2=None):
-    """Enhanced similarity calculation combining geometric and visual features"""
-    try:
-        # Geometric similarity (IoU + distance) - 40% weight
-        geometric_similarity = calculate_bbox_similarity(bbox1, bbox2)
-        
-        # If no frames provided, use only geometric similarity
-        if frame1 is None or frame2 is None:
-            return geometric_similarity
-            
-        # Extract image regions from bounding boxes
-        img1 = extract_bbox_image(frame1, bbox1)
-        img2 = extract_bbox_image(frame2, bbox2)
-        
-        if img1 is None or img2 is None:
-            return geometric_similarity
-            
-        # Visual similarity components
-        hist_similarity = calculate_histogram_similarity(img1, img2)      # Color similarity
-        ssim_similarity = calculate_ssim_similarity(img1, img2)          # Structural similarity
-        feature_similarity = calculate_feature_similarity(img1, img2)     # Feature similarity
-        
-        # Combine all similarities with weights
-        final_similarity = (
-            geometric_similarity * 0.4 +    # Geometric (IoU + distance)
-            hist_similarity * 0.25 +        # Color histogram
-            ssim_similarity * 0.25 +        # Structural similarity
-            feature_similarity * 0.1        # Feature matching
-        )
-        
-        return min(1.0, final_similarity)
-        
-    except Exception as e:
-        return calculate_bbox_similarity(bbox1, bbox2)  # Fallback to geometric only
-
 class TrackedObject:
     def __init__(self, obj_id, obj_class, bbox):
         self.id = obj_id
         self.class_name = obj_class
-        self.alternative_classes = set()  # Track alternative classes (e.g., person when primary is motorcycle)
         self.trajectory = []  # List of center points
         self.bboxes = []     # List of bounding boxes
-        self.frame_images = []  # Store recent frame images for visual comparison
         self.counted = False
         self.last_seen = 0   # Frame number when last seen
         self.first_seen = 0  # Frame number when first seen
@@ -251,42 +103,16 @@ class TrackedObject:
         self.similarity_scores = []  # Track similarity scores over time
         self.add_detection(bbox)
         
-    def update_class(self, new_class):
-        """Update object class, handling motorcycle+person combinations"""
-        # Prioritize motorcycle over person (motorcycle with rider)
-        if self.class_name == 'person' and new_class == 'motorcycle':
-            self.alternative_classes.add(self.class_name)
-            self.class_name = new_class
-        elif self.class_name == 'motorcycle' and new_class == 'person':
-            self.alternative_classes.add(new_class)
-            # Keep motorcycle as primary class
-        elif new_class != self.class_name:
-            # Different class detected, add to alternatives
-            self.alternative_classes.add(new_class)
-    
-    def get_primary_class(self):
-        """Get the primary class for counting purposes"""
-        # Always prioritize motorcycle if it's been detected
-        if 'motorcycle' in [self.class_name] or 'motorcycle' in self.alternative_classes:
-            return 'motorcycle'
-        return self.class_name
-        
-    def add_detection(self, bbox, frame_image=None):
+    def add_detection(self, bbox):
         try:
             center = get_box_center(bbox)
             if center is not None:
                 self.trajectory.append(center)
                 self.bboxes.append(bbox)
-                
-                # Store frame image for visual comparison
-                if frame_image is not None:
-                    self.frame_images.append(frame_image.copy())
-                
                 # Keep only recent history to prevent memory issues
                 if len(self.trajectory) > 50:
                     self.trajectory = self.trajectory[-25:]
                     self.bboxes = self.bboxes[-25:]
-                    self.frame_images = self.frame_images[-25:] if self.frame_images else []
         except Exception as e:
             pass
 
@@ -303,71 +129,32 @@ class TrackedObject:
         if is_in_red_zone:
             if self.red_zone_entry_frame is None:
                 self.red_zone_entry_frame = frame_number
-                # Mark as entered red zone immediately when first detected
-                return "entered"
             self.frames_in_red_zone += 1
             
-            # Check if warning should be triggered using configurable threshold
-            if self.frames_in_red_zone > state.warning_frame_threshold and not self.warning_triggered:
+            # Check if warning should be triggered
+            if self.frames_in_red_zone > 3 and not self.warning_triggered:
                 self.warning_triggered = True
-                return "warning"  # Return warning to indicate warning should be shown
+                return True  # Return True to indicate warning should be shown
         else:
             # Object left red zone, reset counters
-            if self.red_zone_entry_frame is not None:
-                # Object was in red zone and now left
-                self.frames_in_red_zone = 0
-                self.red_zone_entry_frame = None
-                self.warning_triggered = False
-                return "exited"
+            self.frames_in_red_zone = 0
+            self.red_zone_entry_frame = None
+            self.warning_triggered = False
             
-        return None
+        return False
     
-    def get_similarity_with(self, other_bbox, current_frame=None, similarity_threshold=0.5):
-        """Calculate enhanced similarity with another bounding box using visual comparison"""
+    def get_similarity_with(self, other_bbox, similarity_threshold=0.5):
+        """Calculate similarity with another bounding box"""
         if len(self.bboxes) == 0:
             return 0.0
         
         current_bbox = self.bboxes[-1]
-        
-        # Get the most recent frame image for comparison
-        previous_frame = self.frame_images[-1] if self.frame_images else None
-        
-        # Use enhanced similarity calculation with visual comparison
-        similarity = calculate_enhanced_bbox_similarity(
-            current_bbox, 
-            other_bbox, 
-            previous_frame, 
-            current_frame
-        )
-        
-        # Store similarity score for debugging
-        self.similarity_scores.append({
-            'frame': state.frame_count,
-            'similarity': similarity,
-            'bbox': other_bbox,
-            'method': 'enhanced' if (previous_frame is not None and current_frame is not None) else 'geometric'
-        })
-        
-        # Keep only recent similarity scores to prevent memory issues
-        if len(self.similarity_scores) > 20:
-            self.similarity_scores = self.similarity_scores[-10:]
-            
-        return similarity
+        return calculate_bbox_similarity(current_bbox, other_bbox)
 
-def is_similar_object(obj1, obj2, similarity_threshold=0.35):
+def is_similar_object(obj1, obj2, similarity_threshold=0.6):
     """Check if two objects are similar based on class, position and bounding box similarity"""
     try:
-        # Allow cross-class matching for motorcycle and person (same object - person on motorcycle)
-        class1, class2 = obj1['class'], obj2['class']
-        
-        # Check if classes are compatible (same class or motorcycle+person combination)
-        compatible_classes = (
-            class1 == class2 or  # Same class
-            (class1 == 'motorcycle' and class2 == 'person') or  # Person on motorcycle
-            (class1 == 'person' and class2 == 'motorcycle')     # Motorcycle with person
-        )
-        
-        if not compatible_classes:
+        if obj1['class'] != obj2['class']:
             return False
             
         box1 = obj1['bbox']
@@ -386,11 +173,6 @@ def is_similar_object(obj1, obj2, similarity_threshold=0.35):
                 bbox2 = [box2[0], box2[1], box2[0] + box2[2], box2[1] + box2[3]]
                 
             similarity = calculate_bbox_similarity(bbox1, bbox2)
-            
-            # Use lower threshold for motorcycle+person combinations
-            if class1 != class2 and ('motorcycle' in [class1, class2] and 'person' in [class1, class2]):
-                return similarity > (similarity_threshold * 0.7)  # 30% more lenient for cross-class
-            
             return similarity > similarity_threshold
         return False
     except Exception as e:
@@ -415,12 +197,7 @@ class State:
         self.red_zone_passed_objects = defaultdict(int)  # Objects that passed through red zone
         self.red_zone_warnings = []  # Store warning messages
         self.time_window = 10     # Configurable time window for similarity comparison
-        self.similarity_threshold = 0.35  # Configurable similarity threshold (lowered for better matching)
-        self.warning_frame_threshold = 3  # Configurable warning threshold (frames in red zone)
-        # Enhanced red zone tracking
-        self.red_zone_entered_objects = defaultdict(int)  # All objects that entered red zone
-        self.red_zone_current_objects = defaultdict(list)  # Objects currently in red zone
-        self.red_zone_exited_objects = defaultdict(int)   # Objects that exited red zone
+        self.similarity_threshold = 0.6  # Configurable similarity threshold
         
     def reset_tracking(self):
         """Reset all tracking data"""
@@ -430,10 +207,6 @@ class State:
         self.frame_count = 0
         self.red_zone_passed_objects = defaultdict(int)
         self.red_zone_warnings = []
-        # Reset enhanced red zone tracking
-        self.red_zone_entered_objects = defaultdict(int)
-        self.red_zone_current_objects = defaultdict(list)
-        self.red_zone_exited_objects = defaultdict(int)
 
 state = State()
 
@@ -718,15 +491,12 @@ def get_segment_index(choice_text):
     except:
         return -1
 
-def update_object_tracking(objects_in_area, current_frame=None):
+def update_object_tracking(objects_in_area):
     """Update object tracking with new detections"""
     try:
         current_tracked = set()  # Keep track of objects seen in this frame
         current_warnings = []  # Collect warnings for this frame
         
-        # Clear current objects list for this frame
-        state.red_zone_current_objects = defaultdict(list)
-        
         # Match new detections with existing tracked objects
         for obj in objects_in_area:
             try:
@@ -740,97 +510,57 @@ def update_object_tracking(objects_in_area, current_frame=None):
                 best_match_id = None
                 best_similarity = 0.0
                 
-                # Try to match with existing tracked objects using cross-class similarity
+                # Try to match with existing tracked objects using similarity method
                 for obj_id, tracked in state.tracked_objects.items():
-                    # Check if object was seen recently (within time window)
-                    if state.frame_count - tracked.last_seen <= state.time_window:
-                        # Create temporary objects for similarity comparison
-                        temp_obj1 = {'class': tracked.class_name, 'bbox': tracked.bboxes[-1] if tracked.bboxes else bbox}
-                        temp_obj2 = {'class': obj_class, 'bbox': bbox}
-                        
-                        if is_similar_object(temp_obj1, temp_obj2, state.similarity_threshold):
-                            # Use enhanced similarity calculation with visual comparison
-                            similarity = tracked.get_similarity_with(bbox, current_frame)
+                    if tracked.class_name == obj_class:
+                        # Check if object was seen recently (within time window)
+                        if state.frame_count - tracked.last_seen <= state.time_window:
+                            similarity = tracked.get_similarity_with(bbox)
                             
                             # Use the best match above threshold
-                            if similarity > best_similarity:
+                            if similarity > state.similarity_threshold and similarity > best_similarity:
                                 best_similarity = similarity
                                 best_match_id = obj_id
                 
                 # If good match found, update existing object
                 if best_match_id is not None:
                     tracked = state.tracked_objects[best_match_id]
-                    tracked.add_detection(bbox, current_frame)  # Pass current frame
-                    tracked.update_class(obj_class)  # Update class information
+                    tracked.add_detection(bbox)
                     tracked.last_seen = state.frame_count
                     current_tracked.add(best_match_id)
                     matched = True
                     
-                    # Check red zone status and handle state changes
-                    zone_status = tracked.update_red_zone_status(is_in_red_zone, state.frame_count)
-                    primary_class = tracked.get_primary_class()  # Use primary class for counting
-                    
-                    if zone_status == "entered":
-                        # Object just entered red zone - count it immediately
-                        if not tracked.counted:
-                            tracked.counted = True
-                            state.red_zone_entered_objects[primary_class] += 1
-                            
-                    elif zone_status == "warning":
-                        warning_msg = f"⚠️ WARNING: {primary_class} (ID: {tracked.id}) has been in red zone for {tracked.frames_in_red_zone} frames!"
+                    # Check red zone status and warnings
+                    warning_triggered = tracked.update_red_zone_status(is_in_red_zone, state.frame_count)
+                    if warning_triggered:
+                        warning_msg = f"⚠️ WARNING: {tracked.class_name} (ID: {tracked.id}) has been in red zone for {tracked.frames_in_red_zone} frames!"
                         current_warnings.append(warning_msg)
                         state.red_zone_warnings.append({
                             'frame': state.frame_count,
                             'object_id': tracked.id,
-                            'class': primary_class,
+                            'class': tracked.class_name,
                             'frames_in_zone': tracked.frames_in_red_zone,
                             'message': warning_msg
                         })
-                        
-                    elif zone_status == "exited":
-                        # Object exited red zone
-                        state.red_zone_exited_objects[primary_class] += 1
                     
-                    # Add to current objects in red zone if still in zone
-                    if is_in_red_zone:
-                        display_class = primary_class
-                        if tracked.alternative_classes:
-                            display_class += f" ({'+'.join(sorted(tracked.alternative_classes))})"
-                            
-                        state.red_zone_current_objects[primary_class].append({
-                            'id': tracked.id,
-                            'frames_in_zone': tracked.frames_in_red_zone,
-                            'entry_frame': tracked.red_zone_entry_frame,
-                            'display_class': display_class
-                        })
+                    # Check if object should be counted (only count objects that actually move through the zone)
+                    if not tracked.counted and tracked.has_movement() and is_in_red_zone:
+                        # Additional check: object should have been tracked for at least a few frames
+                        if len(tracked.trajectory) >= 3:
+                            tracked.counted = True
+                            state.red_zone_passed_objects[obj_class] += 1
                 
                 # If no match found, create new tracked object
                 if not matched:
                     new_obj = TrackedObject(state.next_obj_id, obj_class, bbox)
-                    new_obj.add_detection(bbox, current_frame)  # Pass current frame
                     new_obj.last_seen = state.frame_count
                     new_obj.first_seen = state.frame_count
                     state.tracked_objects[state.next_obj_id] = new_obj
                     current_tracked.add(state.next_obj_id)
+                    state.next_obj_id += 1
                     
                     # Check red zone status for new object
-                    zone_status = new_obj.update_red_zone_status(is_in_red_zone, state.frame_count)
-                    primary_class = new_obj.get_primary_class()
-                    
-                    if zone_status == "entered":
-                        # New object entered red zone immediately
-                        new_obj.counted = True
-                        state.red_zone_entered_objects[primary_class] += 1
-                        
-                        # Add to current objects in red zone
-                        state.red_zone_current_objects[primary_class].append({
-                            'id': new_obj.id,
-                            'frames_in_zone': new_obj.frames_in_red_zone,
-                            'entry_frame': new_obj.red_zone_entry_frame,
-                            'display_class': primary_class
-                        })
-                    
-                    state.next_obj_id += 1
+                    new_obj.update_red_zone_status(is_in_red_zone, state.frame_count)
                     
             except Exception as e:
                 continue
@@ -839,21 +569,13 @@ def update_object_tracking(objects_in_area, current_frame=None):
         for obj_id, tracked in state.tracked_objects.items():
             if obj_id not in current_tracked:
                 # Object not seen in current frame, update red zone status
-                zone_status = tracked.update_red_zone_status(False, state.frame_count)
-                if zone_status == "exited":
-                    # Object exited red zone
-                    primary_class = tracked.get_primary_class()
-                    state.red_zone_exited_objects[primary_class] += 1
+                tracked.update_red_zone_status(False, state.frame_count)
         
         # Remove objects that haven't been seen for a while
         if state.frame_count > state.time_window:
             to_remove = []
             for obj_id, tracked in state.tracked_objects.items():
                 if state.frame_count - tracked.last_seen > state.time_window * 2:  # Remove after 2x time window
-                    # If object was in red zone when lost, count as exited
-                    if tracked.red_zone_entry_frame is not None:
-                        primary_class = tracked.get_primary_class()
-                        state.red_zone_exited_objects[primary_class] += 1
                     to_remove.append(obj_id)
             
             for obj_id in to_remove:
@@ -867,73 +589,36 @@ def update_object_tracking(objects_in_area, current_frame=None):
         print(f"Error in update_object_tracking: {str(e)}")
 
 def get_red_zone_summary():
-    """Generate comprehensive summary of objects in red zone with proper grouping"""
+    """Generate summary of objects that passed through red zone"""
     summary = []
     
-    # Header
-    summary.append("🔴 RED ZONE MONITORING REPORT")
-    summary.append("=" * 40)
-    
-    # Objects that entered red zone (all time)
-    if state.red_zone_entered_objects:
-        summary.append("\n📊 OBJECTS ENTERED RED ZONE:")
-        total_entered = sum(state.red_zone_entered_objects.values())
-        summary.append(f"Total objects entered: {total_entered}")
+    if state.red_zone_passed_objects:
+        summary.append("🔴 RED ZONE PASSAGE SUMMARY:")
+        total_objects = sum(state.red_zone_passed_objects.values())
+        summary.append(f"Total objects passed: {total_objects}")
         
-        for obj_class, count in sorted(state.red_zone_entered_objects.items()):
+        for obj_class, count in sorted(state.red_zone_passed_objects.items()):
             summary.append(f"  • {obj_class}: {count}")
-    else:
-        summary.append("\n📊 OBJECTS ENTERED RED ZONE:")
-        summary.append("No objects have entered the red zone yet")
     
-    # Objects currently in red zone
-    current_total = sum(len(objects) for objects in state.red_zone_current_objects.values())
-    if current_total > 0:
-        summary.append(f"\n🚨 CURRENTLY IN RED ZONE ({current_total} objects):")
-        
-        for obj_class, objects in sorted(state.red_zone_current_objects.items()):
-            if objects:
-                summary.append(f"  {obj_class} ({len(objects)} objects):")
-                for obj_info in objects:
-                    display_class = obj_info.get('display_class', obj_class)
-                    summary.append(f"    - ID {obj_info['id']}: {obj_info['frames_in_zone']} frames (entered: frame {obj_info['entry_frame']}) [{display_class}]")
-    else:
-        summary.append("\n🚨 CURRENTLY IN RED ZONE:")
-        summary.append("No objects currently in red zone")
+    # Add current objects in red zone
+    current_in_zone = []
+    for obj_id, tracked in state.tracked_objects.items():
+        if tracked.frames_in_red_zone > 0:
+            current_in_zone.append(f"{tracked.class_name} (ID: {tracked.id}, {tracked.frames_in_red_zone} frames)")
     
-    # Objects that exited red zone
-    if state.red_zone_exited_objects:
-        summary.append("\n✅ OBJECTS EXITED RED ZONE:")
-        total_exited = sum(state.red_zone_exited_objects.values())
-        summary.append(f"Total objects exited: {total_exited}")
-        
-        for obj_class, count in sorted(state.red_zone_exited_objects.items()):
-            summary.append(f"  • {obj_class}: {count}")
+    if current_in_zone:
+        summary.append("\n🚨 CURRENTLY IN RED ZONE:")
+        for obj_info in current_in_zone:
+            summary.append(f"  • {obj_info}")
     
-    # Recent warnings
-    recent_warnings = [w for w in state.red_zone_warnings if state.frame_count - w['frame'] <= 10]
+    # Add recent warnings
+    recent_warnings = [w for w in state.red_zone_warnings if state.frame_count - w['frame'] <= 5]
     if recent_warnings:
         summary.append("\n⚠️ RECENT WARNINGS:")
-        for warning in recent_warnings[-5:]:  # Show last 5 warnings
-            summary.append(f"  • Frame {warning['frame']}: {warning['class']} (ID: {warning['object_id']}) - {warning['frames_in_zone']} frames in zone")
+        for warning in recent_warnings[-3:]:  # Show last 3 warnings
+            summary.append(f"  • Frame {warning['frame']}: {warning['message']}")
     
-    # Statistics summary
-    summary.append(f"\n📈 STATISTICS:")
-    summary.append(f"  • Total unique objects tracked: {len(state.tracked_objects)}")
-    summary.append(f"  • Active warnings: {len([w for w in state.red_zone_warnings if state.frame_count - w['frame'] <= 5])}")
-    summary.append(f"  • Frame: {state.frame_count}")
-    summary.append(f"  • Warning threshold: {state.warning_frame_threshold} frames")
-    
-    # Show object combination info
-    combined_objects = 0
-    for tracked in state.tracked_objects.values():
-        if tracked.alternative_classes:
-            combined_objects += 1
-    
-    if combined_objects > 0:
-        summary.append(f"  • Objects with combined detections: {combined_objects}")
-    
-    return "\n".join(summary)
+    return "\n".join(summary) if summary else "No objects detected in red zone yet."
 
 def process_frame(frame, confidence):
     """Process a video frame using cached protection area"""
@@ -1017,7 +702,7 @@ def process_frame(frame, confidence):
                     
                     # Update object tracking
                     state.frame_count += 1
-                    update_object_tracking(objects_in_area, processed_img)
+                    update_object_tracking(objects_in_area)
                     
                     # Cache detections for next frame
                     state.previous_detections = objects_in_area
@@ -1128,59 +813,18 @@ def generate_final_summary():
     summary_lines.append(f"  • Total frames processed: {state.frame_count}")
     summary_lines.append(f"  • Time window used: {state.time_window} frames")
     summary_lines.append(f"  • Similarity threshold: {state.similarity_threshold:.2f}")
-    summary_lines.append(f"  • Warning threshold: {state.warning_frame_threshold} frames")
     
-    # Enhanced red zone summary
-    if state.red_zone_entered_objects:
-        summary_lines.append(f"\n🔴 RED ZONE ANALYSIS:")
-        total_entered = sum(state.red_zone_entered_objects.values())
-        total_exited = sum(state.red_zone_exited_objects.values())
-        
-        summary_lines.append(f"  • Total objects entered red zone: {total_entered}")
-        summary_lines.append(f"  • Total objects exited red zone: {total_exited}")
-        summary_lines.append(f"  • Objects still in red zone: {total_entered - total_exited}")
+    # Red zone passage summary
+    if state.red_zone_passed_objects:
+        summary_lines.append(f"\n🔴 RED ZONE PASSAGE SUMMARY:")
+        total_passed = sum(state.red_zone_passed_objects.values())
+        summary_lines.append(f"  • Total objects passed through red zone: {total_passed}")
         
-        summary_lines.append(f"\n  📋 BREAKDOWN BY OBJECT CLASS:")
-        
-        # Combine all object classes that appeared in red zone
-        all_classes = set(state.red_zone_entered_objects.keys()) | set(state.red_zone_exited_objects.keys())
-        
-        for obj_class in sorted(all_classes):
-            entered = state.red_zone_entered_objects.get(obj_class, 0)
-            exited = state.red_zone_exited_objects.get(obj_class, 0)
-            still_in = entered - exited
-            
-            summary_lines.append(f"    {obj_class}:")
-            summary_lines.append(f"      - Entered: {entered}")
-            summary_lines.append(f"      - Exited: {exited}")
-            summary_lines.append(f"      - Still in zone: {still_in}")
+        for obj_class, count in sorted(state.red_zone_passed_objects.items()):
+            summary_lines.append(f"    - {obj_class}: {count}")
     else:
-        summary_lines.append(f"\n🔴 RED ZONE ANALYSIS:")
-        summary_lines.append(f"  • No objects detected in red zone during processing")
-    
-    # Object combination analysis
-    combined_objects = []
-    motorcycle_person_combinations = 0
-    
-    for obj_id, tracked in state.tracked_objects.items():
-        if tracked.alternative_classes:
-            combo_info = f"ID {obj_id}: {tracked.class_name}"
-            if tracked.alternative_classes:
-                combo_info += f" + {', '.join(sorted(tracked.alternative_classes))}"
-            combined_objects.append(combo_info)
-            
-            # Count motorcycle+person combinations specifically
-            if (tracked.class_name == 'motorcycle' and 'person' in tracked.alternative_classes) or \
-               (tracked.class_name == 'person' and 'motorcycle' in tracked.alternative_classes):
-                motorcycle_person_combinations += 1
-    
-    if combined_objects:
-        summary_lines.append(f"\n🔗 OBJECT COMBINATIONS DETECTED:")
-        summary_lines.append(f"  • Total combined detections: {len(combined_objects)}")
-        summary_lines.append(f"  • Motorcycle+Person combinations: {motorcycle_person_combinations}")
-        summary_lines.append(f"  • Details:")
-        for combo in combined_objects:
-            summary_lines.append(f"    - {combo}")
+        summary_lines.append(f"\n🔴 RED ZONE PASSAGE SUMMARY:")
+        summary_lines.append(f"  • No objects detected passing through red zone")
     
     # Warning summary
     if state.red_zone_warnings:
@@ -1195,14 +839,14 @@ def generate_final_summary():
         for obj_class, count in sorted(warning_by_class.items()):
             summary_lines.append(f"    - {obj_class}: {count} warnings")
             
-        # Show detailed warning log
+        # Show last few warnings
         if len(state.red_zone_warnings) > 0:
-            summary_lines.append(f"\n  📋 Warning Log (last 10):")
-            for warning in state.red_zone_warnings[-10:]:  # Last 10 warnings
+            summary_lines.append(f"\n  📋 Recent warnings:")
+            for warning in state.red_zone_warnings[-5:]:  # Last 5 warnings
                 summary_lines.append(f"    - Frame {warning['frame']}: {warning['class']} (ID: {warning['object_id']}) - {warning['frames_in_zone']} frames in zone")
     else:
         summary_lines.append(f"\n⚠️ WARNING SUMMARY:")
-        summary_lines.append(f"  • No warnings generated (no objects stayed in red zone > {state.warning_frame_threshold} frames)")
+        summary_lines.append(f"  • No warnings generated (no objects stayed in red zone > 3 frames)")
     
     # Active tracking summary
     total_tracked = len(state.tracked_objects)
@@ -1210,17 +854,15 @@ def generate_final_summary():
         summary_lines.append(f"\n📈 OBJECT TRACKING SUMMARY:")
         summary_lines.append(f"  • Total unique objects tracked: {total_tracked}")
         
-        # Group by primary class
+        # Group by class
         objects_by_class = defaultdict(int)
         for obj in state.tracked_objects.values():
-            primary_class = obj.get_primary_class()
-            objects_by_class[primary_class] += 1
+            objects_by_class[obj.class_name] += 1
             
         for obj_class, count in sorted(objects_by_class.items()):
             summary_lines.append(f"    - {obj_class}: {count}")
     
     summary_lines.append("\n✅ Processing completed successfully!")
-    summary_lines.append("\nNote: Objects detected as both motorcycle and person are counted as motorcycle (person riding motorcycle)")
     
     return "\n".join(summary_lines)
 
@@ -1253,7 +895,7 @@ def update_selected_segments(selected):
     state.selected_segments = selected
     return gr.update()
 
-def process_video_wrapper(video, confidence=DEFAULT_CONFIDENCE, target_fps=1, time_window=10, similarity_threshold=0.35, warning_frame_threshold=3):
+def process_video_wrapper(video, confidence=DEFAULT_CONFIDENCE, target_fps=1, time_window=10, similarity_threshold=0.6):
     """Wrapper around process_video to handle full-size video processing"""
     if video is None:
         yield None, "Please upload a video"
@@ -1263,7 +905,6 @@ def process_video_wrapper(video, confidence=DEFAULT_CONFIDENCE, target_fps=1, ti
     state.reset_tracking()
     state.time_window = time_window
     state.similarity_threshold = similarity_threshold
-    state.warning_frame_threshold = warning_frame_threshold
     
     protection_area = []
     if state.selected_segments and state.detected_segments:
@@ -1282,7 +923,7 @@ def process_video_wrapper(video, confidence=DEFAULT_CONFIDENCE, target_fps=1, ti
         return
     
     try:
-        yield None, f"🚀 Starting video processing...\n⚙️ Time window: {time_window} frames\n⚙️ Similarity threshold: {similarity_threshold:.2f}\n⚙️ Warning threshold: {warning_frame_threshold} frames"
+        yield None, f"🚀 Starting video processing...\n⚙️ Time window: {time_window} frames\n⚙️ Similarity threshold: {similarity_threshold:.2f}"
         
         for frame, status in process_video(video, confidence, target_fps):
             yield frame, status
@@ -1290,32 +931,16 @@ def process_video_wrapper(video, confidence=DEFAULT_CONFIDENCE, target_fps=1, ti
     except Exception as e:
         yield None, f"Error processing video: {str(e)}"
 
-# Enhanced Gradio interface
+# Update the Gradio interface
 with gr.Blocks(title="Enhanced Rail Traffic Monitor") as demo:
     gr.Markdown("""
     # Enhanced Rail Traffic Monitoring System
     
     ## Features:
-    - **Smart Object Tracking**: Uses enhanced similarity method combining geometric and visual features
-    - **Visual Similarity Comparison**: Compares actual images within bounding boxes using multiple methods
-    - **Comprehensive Red Zone Monitoring**: Reports ALL objects entering the red zone
-    - **Enhanced Grouping**: Groups objects by class with detailed statistics
-    - **Real-time Status**: Shows objects currently in zone, entered, and exited
-    - **Configurable Warning System**: Alerts when objects stay in red zone for too long
-    - **Configurable Parameters**: Adjust time window, similarity threshold, and warning criteria
-    
-    ## Enhanced Similarity Methods:
-    - **Geometric Similarity** (40%): IoU + center distance
-    - **Color Histogram** (25%): HSV color distribution comparison
-    - **Structural Similarity** (25%): SSIM for shape and texture
-    - **Feature Matching** (10%): ORB keypoint matching
-    - **Default Threshold**: 0.35 (more lenient for better object matching)
-    
-    ## Red Zone Reporting:
-    - **Objects Entered**: Total count of all objects that entered the red zone
-    - **Currently in Zone**: Real-time list of objects currently in the red zone
-    - **Objects Exited**: Count of objects that have left the red zone
-    - **Detailed Grouping**: All statistics grouped by object class (train, car, person, etc.)
+    - **Smart Object Tracking**: Uses similarity method to track objects across frames
+    - **Red Zone Monitoring**: Counts objects passing through the red zone
+    - **Warning System**: Alerts when objects stay in red zone for more than 3 frames
+    - **Configurable Parameters**: Adjust time window and similarity threshold
     
     ## Setup Instructions:
     
@@ -1327,16 +952,14 @@ with gr.Blocks(title="Enhanced Rail Traffic Monitor") as demo:
     1. Click "Extract Protection Area" to automatically detect rail segments
     
     **Processing:**
-    3. Adjust detection confidence, processing frame rate, time window, similarity threshold, and warning threshold
+    3. Adjust detection confidence, processing frame rate, time window, and similarity threshold
     4. Click "Process Video" to analyze
     
-    The system will show comprehensive real-time results including:
-    - All objects that entered the red zone (grouped by class)
-    - Objects currently in red zone with detailed info
-    - Objects that exited the red zone
-    - Enhanced tracking with visual similarity comparison
-    - Configurable warnings for objects staying too long in red zone
-    - Complete tracking statistics
+    The system will show real-time results including:
+    - Objects currently in red zone
+    - Total count of objects that passed through
+    - Warnings for objects staying too long in red zone
+    - Tracking statistics
     """)
     
     with gr.Row():
@@ -1373,21 +996,12 @@ with gr.Blocks(title="Enhanced Rail Traffic Monitor") as demo:
                 similarity_threshold_slider = gr.Slider(
                     minimum=0.1,
                     maximum=0.9,
-                    value=0.35,
+                    value=0.6,
                     step=0.05,
                     label="Similarity Threshold",
                     info="Threshold for considering objects as the same (higher = stricter)"
                 )
-                
-            with gr.Row():
-                warning_threshold_slider = gr.Slider(
-                    minimum=1,
-                    maximum=20,
-                    value=3,
-                    step=1,
-                    label="Warning Frame Threshold",
-                    info="Number of frames in red zone before triggering warning"
-                )
+            
         with gr.Column():
             preview_image = gr.Image(
                 label="Click to Select Protection Area (Original Size)",
@@ -1447,7 +1061,7 @@ with gr.Blocks(title="Enhanced Rail Traffic Monitor") as demo:
     
     process_btn.click(
         fn=process_video_wrapper,
-        inputs=[video_input, confidence, fps_slider, time_window_slider, similarity_threshold_slider, warning_threshold_slider],
+        inputs=[video_input, confidence, fps_slider, time_window_slider, similarity_threshold_slider],
         outputs=[video_output, text_output]
     )