Update app.py

app.py

@@ -95,8 +95,6 @@ def initialize_model():
     try:
         logger.info("Initializing YOLOv8 model...")
         yolo_model = YOLO(MODEL_PATH)
-        # Set model to evaluation mode for better accuracy
-        yolo_model.model.eval()
         logger.info("YOLOv8 model loaded successfully")
         return True
     except Exception as e:
@@ -315,14 +313,14 @@ def generate_and_upload_report_to_salesforce(sf, violations, record_ids):
         logger.error(f"Error in Salesforce PDF report generation/upload: {e}", exc_info=True)
         return None, None
 
-# --- Enhanced Safety Violation Detector Class with Precise Visualization ---
+# --- Enhanced Safety Violation Detector Class with Group Detection ---
 class SafetyViolationDetector:
     def __init__(self):
-        # Enhanced detection thresholds for better accuracy
-        self.helmet_threshold = 0.65  # Lowered for better sensitivity
-        self.person_threshold = 0.55  # Lowered for better sensitivity
-        self.unsafe_distance = 60  # Increased for better safety margin
-        self.violation_cooldown = 15  # Reduced for faster response
+        # Detection thresholds (fine-tuned for better accuracy)
+        self.helmet_threshold = 0.75
+        self.person_threshold = 0.60
+        self.unsafe_distance = 50  # pixels
+        self.violation_cooldown = 20  # seconds
 
         # Unauthorized zones (x1, y1, x2, y2)
         self.unauthorized_zones = [
@@ -335,27 +333,17 @@ class SafetyViolationDetector:
         self.person_tracker = {}
         self.person_positions_history = {}
         self.next_person_id = 1
-        self.max_tracking_distance = 100
+        self.max_tracking_distance = 120
 
         self.session_violations = {}
 
-        # Enhanced visualization colors
-        self.colors = {
-            'no_helmet': (0, 0, 255),      # Red for critical
-            'unauthorized': (255, 0, 255),  # Magenta for high
-            'unsafe_distance': (0, 165, 255), # Orange for moderate
-            'safe': (0, 255, 0),           # Green for safe
-            'person': (255, 255, 0),       # Cyan for person detection
-            'helmet': (0, 255, 255)        # Yellow for helmet detection
-        }
-
     def reset_session(self):
         self.session_violations = {}
         self.active_violations = {}
         self.person_tracker = {}
         self.person_positions_history = {}
         self.next_person_id = 1
-        logger.info("Session violation tracking reset for new analysis")
+        logger.info("Session violation tracking reset for new video")
 
     def has_reported_violation(self, person_id, violation_type):
         if person_id not in self.session_violations:
@@ -430,7 +418,6 @@ class SafetyViolationDetector:
         persons = []
         helmets = []
 
-        # Enhanced detection with confidence filtering
         for box, conf, cls_id in zip(boxes, confidences, class_ids):
             class_name = class_names[cls_id]
             if class_name == "person" and conf >= self.person_threshold:
@@ -441,17 +428,12 @@ class SafetyViolationDetector:
                     'center': ((box[0] + box[2]) / 2, (box[1] + box[3]) / 2),
                     'id': person_id
                 })
-                # Draw person detection box
-                self._draw_enhanced_person_box(frame, box, person_id, conf)
-                
-            elif class_name in ["hard hat", "helmet", "safety helmet"] and conf >= self.helmet_threshold:
+            elif class_name == "hard hat" and conf >= self.helmet_threshold:
                 helmets.append({
                     'box': box,
                     'confidence': conf,
                     'area': (box[2] - box[0]) * (box[3] - box[1])
                 })
-                # Draw helmet detection box
-                self._draw_helmet_box(frame, box, conf)
 
         current_person_ids = set()
         for person in persons:
@@ -472,7 +454,6 @@ class SafetyViolationDetector:
                 if len(self.person_tracker[person_id]['positions']) > 10:
                     self.person_tracker[person_id]['positions'].pop(0)
 
-        # Check violations with enhanced visualization
         for person in persons:
             person_id = person['id']
 
@@ -490,40 +471,9 @@ class SafetyViolationDetector:
         self._cleanup_violations(current_time)
         self._cleanup_inactive_persons(current_person_ids, current_time)
 
-        logger.info(f"Enhanced violation detection time: {time.time() - start_time:.2f}s")
+        logger.info(f"Violation detection time: {time.time() - start_time:.2f}s")
         return violations
 
-    def _draw_enhanced_person_box(self, frame, box, person_id, confidence):
-        """Draw enhanced person detection box with ID and confidence"""
-        x1, y1, x2, y2 = map(int, box)
-        
-        # Draw main bounding box
-        cv2.rectangle(frame, (x1, y1), (x2, y2), self.colors['person'], 2)
-        
-        # Draw ID and confidence label
-        label = f"Person {person_id:03d} ({confidence:.2f})"
-        label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)[0]
-        
-        # Background for label
-        cv2.rectangle(frame, (x1, y1 - label_size[1] - 10), 
-                     (x1 + label_size[0] + 10, y1), self.colors['person'], -1)
-        
-        # Label text
-        cv2.putText(frame, label, (x1 + 5, y1 - 5),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 2)
-
-    def _draw_helmet_box(self, frame, box, confidence):
-        """Draw helmet detection box"""
-        x1, y1, x2, y2 = map(int, box)
-        
-        # Draw helmet bounding box
-        cv2.rectangle(frame, (x1, y1), (x2, y2), self.colors['helmet'], 2)
-        
-        # Draw helmet label
-        label = f"Helmet ({confidence:.2f})"
-        cv2.putText(frame, label, (x1, y1 - 10),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, self.colors['helmet'], 2)
-
     def _check_helmet_violation(self, person, helmets, frame, current_time):
         person_id = person['id']
         person_box = person['box']
@@ -532,29 +482,17 @@ class SafetyViolationDetector:
         if self.has_reported_violation(person_id, violation_type):
             return None
 
-        # Enhanced head region calculation (upper 30% of person box)
-        person_height = person_box[3] - person_box[1]
         head_region = [
-            person_box[0] - 10,  # Slightly expand horizontally
-            person_box[1],
-            person_box[2] + 10,  # Slightly expand horizontally
-            person_box[1] + (person_height * 0.35)  # Upper 35% for head
+            person_box[0],
+            max(person_box[1], person_box[1] + (person_box[3] - person_box[1]) * 0.3),
+            person_box[2],
+            person_box[1] + (person_box[3] - person_box[1]) * 0.3
         ]
 
-        # Draw head region for visualization
-        hx1, hy1, hx2, hy2 = map(int, head_region)
-        cv2.rectangle(frame, (hx1, hy1), (hx2, hy2), (255, 255, 255), 1)
-        cv2.putText(frame, "Head Region", (hx1, hy1 - 5),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1)
-
         has_helmet = False
-        best_helmet_iou = 0
-        
         for helmet in helmets:
-            iou = self._iou(helmet['box'], head_region)
-            if iou > 0.05:  # Lowered threshold for better detection
+            if self._iou(helmet['box'], head_region) > 0.1:
                 has_helmet = True
-                best_helmet_iou = max(best_helmet_iou, iou)
                 break
 
         self.person_tracker[person_id]['helmet_status'] = has_helmet
@@ -583,8 +521,7 @@ class SafetyViolationDetector:
                 self.person_tracker[person_id]['violations']['no_helmet']['count'] += 1
                 self.person_tracker[person_id]['violations']['no_helmet']['last_time'] = current_time
 
-                # Enhanced violation annotation - focus on head area
-                self._annotate_helmet_violation(frame, person_box, head_region, person_id)
+                self._annotate_frame(frame, person_box, person_id, "NO HELMET", (0, 0, 255))
                 logger.info(f"NEW VIOLATION: No helmet detected for person {person_id}")
 
                 return {
@@ -597,51 +534,8 @@ class SafetyViolationDetector:
             else:
                 self.active_violations[violation_key]['last_detected'] = current_time
                 self.active_violations[violation_key]['count'] += 1
-        else:
-            # Draw safe helmet status
-            px1, py1, px2, py2 = map(int, person_box)
-            cv2.putText(frame, "✓ HELMET OK", (px1, py2 + 20),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, self.colors['safe'], 2)
-        
         return None
 
-    def _annotate_helmet_violation(self, frame, person_box, head_region, person_id):
-        """Enhanced helmet violation annotation focusing on head area"""
-        px1, py1, px2, py2 = map(int, person_box)
-        hx1, hy1, hx2, hy2 = map(int, head_region)
-        
-        # Draw critical violation box around person
-        cv2.rectangle(frame, (px1, py1), (px2, py2), self.colors['no_helmet'], 3)
-        
-        # Highlight head region with pulsing effect
-        cv2.rectangle(frame, (hx1, hy1), (hx2, hy2), self.colors['no_helmet'], 4)
-        
-        # Draw warning symbol at head center
-        head_center_x = (hx1 + hx2) // 2
-        head_center_y = (hy1 + hy2) // 2
-        
-        # Warning triangle
-        triangle_pts = np.array([
-            [head_center_x, hy1 + 5],
-            [head_center_x - 15, hy2 - 5],
-            [head_center_x + 15, hy2 - 5]
-        ], np.int32)
-        cv2.fillPoly(frame, [triangle_pts], (0, 255, 255))
-        cv2.putText(frame, "!", (head_center_x - 5, head_center_y + 5),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 0), 2)
-        
-        # Critical violation label
-        label = f"CRITICAL: NO HELMET - ID:{person_id:03d}"
-        label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)[0]
-        
-        # Background for label
-        cv2.rectangle(frame, (px1, py1 - label_size[1] - 15), 
-                     (px1 + label_size[0] + 10, py1 - 5), self.colors['no_helmet'], -1)
-        
-        # Label text
-        cv2.putText(frame, label, (px1 + 5, py1 - 10),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
-
     def _check_unauthorized_area(self, person, frame, current_time):
         person_id = person['id']
         violation_type = 'unauthorized_area'
@@ -652,16 +546,10 @@ class SafetyViolationDetector:
         x1, y1, x2, y2 = person['box']
         person_center = ((x1 + x2) / 2, (y1 + y2) / 2)
 
-        for zone_idx, zone in enumerate(self.unauthorized_zones):
+        for zone in self.unauthorized_zones:
             zx1, zy1, zx2, zy2 = zone
-            
-            # Draw unauthorized zone
-            cv2.rectangle(frame, (zx1, zy1), (zx2, zy2), self.colors['unauthorized'], 2)
-            cv2.putText(frame, f"RESTRICTED ZONE {zone_idx + 1}", (zx1, zy1 - 10),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, self.colors['unauthorized'], 2)
-            
             if (zx1 <= person_center[0] <= zx2 and zy1 <= person_center[1] <= zy2):
-                violation_key = f"unauthorized_area_{person_id}_{zone_idx}"
+                violation_key = f"unauthorized_area_{person_id}_{zx1}_{zy1}"
 
                 if (violation_key not in self.active_violations or
                         current_time - self.active_violations[violation_key]['last_detected'] > self.violation_cooldown):
@@ -685,8 +573,8 @@ class SafetyViolationDetector:
                     self.person_tracker[person_id]['violations']['unauthorized_area']['count'] += 1
                     self.person_tracker[person_id]['violations']['unauthorized_area']['last_time'] = current_time
 
-                    # Enhanced unauthorized area annotation
-                    self._annotate_unauthorized_violation(frame, person['box'], zone, person_id, zone_idx)
+                    cv2.rectangle(frame, (zx1, zy1), (zx2, zy2), (255, 0, 255), 2)
+                    self._annotate_frame(frame, person['box'], person_id, "UNAUTHORIZED", (255, 0, 255))
                     logger.info(f"NEW VIOLATION: Unauthorized area detected for person {person_id}")
 
                     return {
@@ -702,34 +590,6 @@ class SafetyViolationDetector:
                     self.active_violations[violation_key]['count'] += 1
         return None
 
-    def _annotate_unauthorized_violation(self, frame, person_box, zone, person_id, zone_idx):
-        """Enhanced unauthorized area violation annotation"""
-        px1, py1, px2, py2 = map(int, person_box)
-        zx1, zy1, zx2, zy2 = zone
-        
-        # Draw thick violation box around person
-        cv2.rectangle(frame, (px1, py1), (px2, py2), self.colors['unauthorized'], 4)
-        
-        # Highlight the restricted zone
-        cv2.rectangle(frame, (zx1, zy1), (zx2, zy2), self.colors['unauthorized'], 3)
-        
-        # Draw line from person to zone center
-        person_center = ((px1 + px2) // 2, (py1 + py2) // 2)
-        zone_center = ((zx1 + zx2) // 2, (zy1 + zy2) // 2)
-        cv2.line(frame, person_center, zone_center, self.colors['unauthorized'], 3)
-        
-        # Warning label
-        label = f"HIGH: UNAUTHORIZED AREA {zone_idx + 1} - ID:{person_id:03d}"
-        label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)[0]
-        
-        # Background for label
-        cv2.rectangle(frame, (px1, py1 - label_size[1] - 15), 
-                     (px1 + label_size[0] + 10, py1 - 5), self.colors['unauthorized'], -1)
-        
-        # Label text
-        cv2.putText(frame, label, (px1 + 5, py1 - 10),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
-
     def _check_distance_violations(self, persons, frame, current_time):
         violations = []
         if len(persons) < 2:
@@ -775,9 +635,8 @@ class SafetyViolationDetector:
                             self.person_tracker[pid]['violations']['unsafe_distance']['count'] += 1
                             self.person_tracker[pid]['violations']['unsafe_distance']['last_time'] = current_time
 
-                        # Enhanced distance violation annotation
-                        self._annotate_distance_violation(frame, persons[i]['box'], persons[j]['box'],
-                                                        person1_id, person2_id, dist)
+                        self._annotate_distance(frame, persons[i]['box'], persons[j]['box'],
+                                                person1_id, person2_id, dist)
                         logger.info(f"NEW VIOLATION: Unsafe distance detected between persons {person1_id} and {person2_id}")
 
                         violations.append({
@@ -795,57 +654,6 @@ class SafetyViolationDetector:
                         self.active_violations[violation_key]['count'] += 1
         return violations
 
-    def _annotate_distance_violation(self, frame, box1, box2, id1, id2, dist):
-        """Enhanced distance violation annotation with precise visualization"""
-        x1, y1, x2, y2 = map(int, box1)
-        x3, y3, x4, y4 = map(int, box2)
-        
-        # Draw violation boxes around both persons
-        cv2.rectangle(frame, (x1, y1), (x2, y2), self.colors['unsafe_distance'], 3)
-        cv2.rectangle(frame, (x3, y3), (x4, y4), self.colors['unsafe_distance'], 3)
-        
-        # Calculate centers
-        center1 = ((x1 + x2) // 2, (y1 + y2) // 2)
-        center2 = ((x3 + x4) // 2, (y3 + y4) // 2)
-        
-        # Draw distance line with measurement
-        cv2.line(frame, center1, center2, self.colors['unsafe_distance'], 4)
-        
-        # Draw circles at person centers
-        cv2.circle(frame, center1, 8, self.colors['unsafe_distance'], -1)
-        cv2.circle(frame, center2, 8, self.colors['unsafe_distance'], -1)
-        
-        # Distance measurement
-        mid_point = ((center1[0] + center2[0]) // 2, (center1[1] + center2[1]) // 2)
-        distance_text = f"{dist:.1f}px"
-        
-        # Background for distance text
-        text_size = cv2.getTextSize(distance_text, cv2.FONT_HERSHEY_SIMPLEX, 0.8, 2)[0]
-        cv2.rectangle(frame, (mid_point[0] - text_size[0]//2 - 5, mid_point[1] - text_size[1] - 5),
-                     (mid_point[0] + text_size[0]//2 + 5, mid_point[1] + 5), 
-                     self.colors['unsafe_distance'], -1)
-        
-        cv2.putText(frame, distance_text, (mid_point[0] - text_size[0]//2, mid_point[1]),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)
-        
-        # Warning labels for both persons
-        label1 = f"MODERATE: UNSAFE DISTANCE - ID:{id1:03d}"
-        label2 = f"MODERATE: UNSAFE DISTANCE - ID:{id2:03d}"
-        
-        # Label for person 1
-        label_size1 = cv2.getTextSize(label1, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)[0]
-        cv2.rectangle(frame, (x1, y1 - label_size1[1] - 15), 
-                     (x1 + label_size1[0] + 10, y1 - 5), self.colors['unsafe_distance'], -1)
-        cv2.putText(frame, label1, (x1 + 5, y1 - 10),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-        
-        # Label for person 2
-        label_size2 = cv2.getTextSize(label2, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)[0]
-        cv2.rectangle(frame, (x3, y3 - label_size2[1] - 15), 
-                     (x3 + label_size2[0] + 10, y3 - 5), self.colors['unsafe_distance'], -1)
-        cv2.putText(frame, label2, (x3 + 5, y3 - 10),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-
     def _cleanup_violations(self, current_time):
         expired_violations = [
             k for k, v in self.active_violations.items()
@@ -866,6 +674,25 @@ class SafetyViolationDetector:
             if pid in self.person_positions_history:
                 del self.person_positions_history[pid]
 
+    def _annotate_frame(self, frame, box, person_id, violation_type, color):
+        x1, y1, x2, y2 = map(int, box)
+        cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
+        label = f"ID:{person_id:03d} {violation_type}"
+        cv2.putText(frame, label, (x1, y1 - 10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
+    def _annotate_distance(self, frame, box1, box2, id1, id2, dist):
+        x1, y1, x2, y2 = map(int, box1)
+        x3, y3, x4, y4 = map(int, box2)
+        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 165, 255), 2)
+        cv2.rectangle(frame, (x3, y3), (x4, y4), (0, 165, 255), 2)
+        center1 = ((x1 + x2) // 2, (y1 + y2) // 2)
+        center2 = ((x3 + x4) // 2, (y3 + y4) // 2)
+        cv2.line(frame, center1, center2, (0, 165, 255), 2)
+        mid_point = ((center1[0] + center2[0]) // 2, (center1[1] + center2[1]) // 2)
+        cv2.putText(frame, f"{dist:.1f}px", mid_point,
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 165, 255), 2)
+
     def _iou(self, box1, box2):
         x1 = max(box1[0], box2[0])
         y1 = max(box1[1], box2[1])
@@ -901,37 +728,16 @@ class SafetyViolationDetector:
 
         return summary
 
-# --- Enhanced Frame Processing Functions ---
+# --- Frame Processing Functions ---
 def preprocess_frame(frame):
-    """Enhanced frame preprocessing for better detection accuracy"""
     try:
-        # Apply noise reduction
-        frame = cv2.bilateralFilter(frame, 9, 75, 75)
-        
-        # Enhance contrast and brightness
-        frame = cv2.convertScaleAbs(frame, alpha=1.3, beta=25)
-        
-        # Apply histogram equalization for better lighting
-        lab = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)
-        lab[:,:,0] = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8)).apply(lab[:,:,0])
-        frame = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
-        
-        # Convert to RGB for YOLO
+        # Enhance image for better detection
+        frame = cv2.convertScaleAbs(frame, alpha=1.2, beta=20)  # Increase contrast
         img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        
-        # Resize while maintaining aspect ratio
-        height, width = img.shape[:2]
-        if width > 640 or height > 640:
-            scale = min(640/width, 640/height)
-            new_width = int(width * scale)
-            new_height = int(height * scale)
-            img_resized = cv2.resize(img, (new_width, new_height), interpolation=cv2.INTER_LANCZOS4)
-        else:
-            img_resized = img
-            
+        img_resized = cv2.resize(img, (320, 320))  # Reduced resolution
         return img_resized
     except Exception as e:
-        logger.error(f"Enhanced frame preprocessing error: {e}")
+        logger.error(f"Frame preprocessing error: {e}")
         raise
 
 def capture_rtsp_frames(rtsp_url, max_frames=None):
@@ -958,18 +764,21 @@ def capture_rtsp_frames(rtsp_url, max_frames=None):
     finally:
         cv2.destroyAllWindows()
 
-# --- Enhanced Image Processing Function ---
+# --- Image Processing Function ---
 async def process_image(image_path, progress=gr.Progress()):
-    """Enhanced image processing with precise violation detection and visualization"""
+    """Process a single image for safety violations"""
     try:
+        logger.info(f"Starting image analysis: {image_path}")
+        start_time = time.time()
+        
         current_run_violations = []
         new_sf_record_ids = []
         violation_payloads = []
         tracker = SafetyViolationDetector()
-
+        
         tracker.reset_session()
         logger.info("Starting new image analysis session")
-
+        
         # Get Salesforce connection
         sf = None
         if SALESFORCE_ENABLED:
@@ -977,38 +786,37 @@ async def process_image(image_path, progress=gr.Progress()):
                 sf = get_salesforce_connection()
             except Exception as e:
                 logger.error(f"Could not connect to Salesforce: {e}")
-
-        progress(0.1, desc="Loading and preprocessing image...")
-
-        # Load and preprocess image
+        
+        progress(0.1, desc="Loading image...")
+        
+        # Load image
         frame = cv2.imread(image_path)
         if frame is None:
-            raise ValueError(f"Could not load image: {image_path}")
-
-        original_frame = frame.copy()
+            error_msg = f"Failed to load image: {image_path}"
+            logger.error(error_msg)
+            return None, error_msg, None, format_violations_as_text([])
+        
+        progress(0.3, desc="Preprocessing image...")
+        
+        # Preprocess image
         processed_frame = preprocess_frame(frame)
-
-        progress(0.3, desc="Running AI detection...")
-
-        # Run YOLO detection with enhanced parameters
-        results = yolo_model.predict(
-            processed_frame,
-            conf=0.4,  # Lower confidence for better detection
-            iou=0.5,   # Adjusted IoU threshold
-            verbose=False,
-            save=False
-        )
-
-        progress(0.6, desc="Analyzing violations...")
-
-        # Detect violations with enhanced visualization
+        
+        progress(0.5, desc="Running AI detection...")
+        
+        # Run YOLO detection
+        results = yolo_model.predict(processed_frame)
+        
+        progress(0.7, desc="Analyzing violations...")
+        
+        # Detect violations
         violations = tracker.detect_violations(results, frame)
+        
+        violation_count = 0
         timestamp = datetime.now(IST).isoformat()
-
-        progress(0.8, desc="Processing results...")
-
-        # Process violations
+        
+        # Process each violation
         for violation in violations:
+            violation_count += 1
             snapshot_url = save_snapshot(frame, save_to_disk=False)
             worker_id = f"WORKER{violation.get('person_id', 'UNKNOWN')}"
             if violation['type'] == 'unsafe_distance':
@@ -1022,81 +830,158 @@ async def process_image(image_path, progress=gr.Progress()):
                 'site_id': 'SITE001',
                 'camera_id': 'CAM001',
                 'worker_id': worker_id,
-                'frame_number': 1
+                'frame_number': 1  # Single image
             }
-
+            
             if violation['type'] == 'unsafe_distance':
                 violation_data['distance'] = f"{violation['distance']:.1f}px"
-
+            
             current_run_violations.append(violation_data)
             log_violation(violation_data)
             send_alert(violation_data)
-
+            
+            # Prepare Salesforce record
             if sf:
                 payload, error = create_salesforce_violation_record(sf, violation_data)
                 if payload:
                     violation_payloads.append(payload)
                 else:
-                    logger.error(f"Salesforce push failed for violation: {error}")
-
-        # Create Salesforce records
+                    logger.error(f"Salesforce payload creation failed: {error}")
+        
+        progress(0.8, desc="Creating Salesforce records...")
+        
+        # Create Salesforce records in bulk
         if sf and violation_payloads:
             try:
                 results = sf.bulk.Safety_Violation_Log__c.insert(violation_payloads)
                 new_sf_record_ids = [result['id'] for result in results if result.get('success')]
                 logger.info(f"Created {len(new_sf_record_ids)} Salesforce records")
+                for result in results:
+                    if not result.get('success'):
+                        logger.error(f"Failed to create record: {result.get('errors')}")
             except Exception as e:
-                logger.error(f"Failed to create Salesforce records: {e}")
-
+                logger.error(f"Failed to create bulk Salesforce records: {e}")
+        
         progress(0.9, desc="Generating report...")
-
-        # Generate PDF report
+        
+        # Generate PDF report if violations found
         pdf_temp_path = None
         if sf and new_sf_record_ids and current_run_violations:
-            pdf_temp_path, pdf_sf_url = generate_and_upload_report_to_salesforce(sf, current_run_violations, new_sf_record_ids)
-
-        progress(1.0, desc="Analysis complete!")
-
+            logger.info("Generating and uploading PDF report to Salesforce...")
+            pdf_temp_path, pdf_sf_url = generate_and_upload_report_to_salesforce(
+                sf, current_run_violations, new_sf_record_ids
+            )
+            if not pdf_temp_path:
+                logger.error("Failed to generate Salesforce report")
+        elif current_run_violations and not sf:
+            # Generate local PDF if no Salesforce
+            pdf_temp_path = generate_local_pdf_report(current_run_violations)
+        
+        processing_time = time.time() - start_time
         session_summary = tracker.get_session_summary()
-        logger.info(f"Image analysis complete. Session summary: {session_summary}")
-
+        
+        progress(1.0, desc="Analysis complete!")
+        
         # Generate status message
-        if current_run_violations:
+        if violation_count > 0:
             status_message = f"""✅ IMAGE ANALYSIS COMPLETED
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 📊 RESULTS:
-• Image processed successfully
-• Enhanced detection algorithms applied
-• Precise violation visualization enabled
-
-👥 PERSONS DETECTED: {session_summary['total_persons']}
-🚨 UNIQUE VIOLATIONS: {len(current_run_violations)}
-🔍 VIOLATION TYPES: {', '.join(session_summary['violations_by_type'].keys()) if session_summary['violations_by_type'] else 'None'}
-
+• Processing Time: {processing_time:.2f}s
+• Image: {os.path.basename(image_path)}
+👥 UNIQUE PERSONS TRACKED: {session_summary['total_persons']}
+🔍 VIOLATION TYPES: {', '.join(session_summary['violations_by_type'].keys())}
+🚨 UNIQUE VIOLATIONS: {violation_count}
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Each violation precisely marked with enhanced visualization"""
+Each violation reported only once per person"""
         else:
             status_message = f"""✅ IMAGE ANALYSIS COMPLETED
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 📊 RESULTS:
-• Image processed successfully
-• Enhanced detection algorithms applied
-• Precise violation visualization enabled
-
-👥 PERSONS DETECTED: {session_summary['total_persons']}
+• Processing Time: {processing_time:.2f}s
+• Image: {os.path.basename(image_path)}
+👥 UNIQUE PERSONS TRACKED: {session_summary['total_persons']}
 ✅ NO VIOLATIONS DETECTED
-
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 All safety protocols followed"""
-
-        return [frame], status_message, pdf_temp_path, format_violations_as_text(current_run_violations)
-
+        
+        logger.info(f"Image analysis complete. Processing time: {processing_time:.2f}s")
+        
+        # Return annotated frame if violations found
+        output_frames = [frame] if violations else None
+        
+        return output_frames, status_message, pdf_temp_path, format_violations_as_text(current_run_violations)
+        
     except Exception as e:
-        logger.error(f"Enhanced image processing error: {e}")
+        logger.error(f"Image processing error: {e}", exc_info=True)
         error_message = f"Image processing failed: {str(e)}"
         return None, error_message, None, format_violations_as_text([])
 
-# --- Enhanced Video Processing Functions ---
+def generate_local_pdf_report(violations):
+    """Generate a local PDF report when Salesforce is not available"""
+    try:
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf', prefix='safety_report_')
+        c = canvas.Canvas(temp_file.name, pagesize=letter)
+        c.setFont("Helvetica-Bold", 16)
+        c.drawString(100, 750, "Safety Violation Report")
+        c.setFont("Helvetica", 12)
+        c.drawString(100, 730, f"Generated: {datetime.now(IST).strftime('%Y-%m-%d %H:%M:%S IST')}")
+        c.setFont("Helvetica", 10)
+        c.drawString(100, 710, "Note: Each violation type reported only once per person")
+
+        y = 680
+        for i, violation in enumerate(violations, 1):
+            c.setFont("Helvetica-Bold", 12)
+            c.drawString(100, y, f"Violation #{i}: {violation['violation_type']}")
+            y -= 20
+            c.setFont("Helvetica", 10)
+            c.drawString(120, y, f"Severity: {violation['severity']}")
+            y -= 15
+            c.drawString(120, y, f"Time: {violation['timestamp']}")
+            y -= 15
+            c.drawString(120, y, f"Worker: {violation.get('worker_id', 'UNKNOWN')}")
+            y -= 15
+            if 'distance' in violation:
+                c.drawString(120, y, f"Distance: {violation['distance']}")
+                y -= 15
+            y -= 20
+            if y < 50:
+                c.showPage()
+                y = 750
+
+        c.save()
+        temp_file.close()
+        return temp_file.name
+    except Exception as e:
+        logger.error(f"Local PDF generation error: {e}")
+        return None
+
+# --- Media Processing Handler ---
+async def process_media(media_file, frame_skip=5, progress=gr.Progress()):
+    """Handle both image and video processing"""
+    if media_file is None:
+        return None, "No file uploaded", None, format_violations_as_text([])
+    
+    file_path = media_file.name
+    file_extension = os.path.splitext(file_path)[1].lower()
+    
+    # Image extensions
+    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif', '.webp'}
+    # Video extensions  
+    video_extensions = {'.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv', '.webm', '.m4v'}
+    
+    if file_extension in image_extensions:
+        logger.info(f"Processing image: {file_path}")
+        return await process_image(file_path, progress)
+    elif file_extension in video_extensions:
+        logger.info(f"Processing video: {file_path}")
+        return await process_video(file_path, frame_skip, progress)
+    else:
+        error_msg = f"Unsupported file format: {file_extension}. Please upload an image or video file."
+        logger.error(error_msg)
+        return None, error_msg, None, format_violations_as_text([])
+
+# --- Video Processing Functions ---
 async def process_video(video_path, frame_skip=5, progress=gr.Progress()):
     global processing_active
     processing_active = True
@@ -1109,7 +994,7 @@ async def process_video(video_path, frame_skip=5, progress=gr.Progress()):
         tracker = SafetyViolationDetector()
 
         tracker.reset_session()
-        logger.info("Starting new enhanced video analysis session")
+        logger.info("Starting new video analysis session")
 
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
@@ -1118,7 +1003,7 @@ async def process_video(video_path, frame_skip=5, progress=gr.Progress()):
             return None, error_message, None, format_violations_as_text([])
 
         frames = []
-        max_display_frames = 15  # Increased for better visualization
+        max_display_frames = 10
         frame_count = 0
         processed_frames = 0
         violation_count = 0
@@ -1135,7 +1020,7 @@ async def process_video(video_path, frame_skip=5, progress=gr.Progress()):
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         duration = total_frames / fps if fps > 0 else 0
 
-        progress(0, desc="Analyzing video with enhanced detection...")
+        progress(0, desc="Analyzing video...")
 
         while cap.isOpened() and processing_active:
             ret, frame = cap.read()
@@ -1150,19 +1035,10 @@ async def process_video(video_path, frame_skip=5, progress=gr.Progress()):
             timestamp = datetime.now(IST).isoformat()
 
             progress_percent = min(100, (frame_count / total_frames) * 100)
-            progress(progress_percent / 100, desc=f"Enhanced processing frame {frame_count}/{total_frames}")
+            progress(progress_percent / 100, desc=f"Processing frame {frame_count}/{total_frames}")
 
-            # Enhanced preprocessing
             processed_frame = preprocess_frame(frame)
-            
-            # Enhanced YOLO detection
-            results = yolo_model.predict(
-                processed_frame,
-                conf=0.4,  # Lower confidence for better detection
-                iou=0.5,   # Adjusted IoU threshold
-                verbose=False,
-                save=False
-            )
+            results = yolo_model.predict(processed_frame)
 
             violations = tracker.detect_violations(results, frame)
 
@@ -1229,13 +1105,16 @@ async def process_video(video_path, frame_skip=5, progress=gr.Progress()):
             pdf_temp_path, pdf_sf_url = generate_and_upload_report_to_salesforce(sf, current_run_violations, new_sf_record_ids)
             if not pdf_temp_path:
                  logger.error("Failed to generate and upload Salesforce report.")
+        elif current_run_violations and not sf:
+            # Generate local PDF if no Salesforce
+            pdf_temp_path = generate_local_pdf_report(current_run_violations)
         elif not current_run_violations:
             logger.info("No violations detected, skipping report generation.")
         else:
             logger.warning("Salesforce not configured or no violations recorded. Skipping Salesforce report upload.")
            
         session_summary = tracker.get_session_summary()
-        logger.info(f"Enhanced video analysis complete. Session summary: {session_summary}")
+        logger.info(f"Video analysis complete. Session summary: {session_summary}")
         logger.info(f"Total processing time: {processing_time:.2f}s")
 
         status_message = generate_status_message(
@@ -1251,7 +1130,7 @@ async def process_video(video_path, frame_skip=5, progress=gr.Progress()):
 
         return frames, status_message, pdf_temp_path, format_violations_as_text(current_run_violations)
     except Exception as e:
-        logger.error(f"Enhanced video processing error: {e}", exc_info=True)
+        logger.error(f"Video processing error: {e}", exc_info=True)
         error_message = f"Video processing failed: {str(e)}"
         return None, error_message, None, format_violations_as_text([])
     finally:
@@ -1259,31 +1138,6 @@ async def process_video(video_path, frame_skip=5, progress=gr.Progress()):
         cv2.destroyAllWindows()
         logger.info(f"Total processing time: {time.time() - start_total:.2f}s")
 
-# --- Smart Media Processing Function ---
-async def process_media(media_file, frame_skip=5, progress=gr.Progress()):
-    """Smart media processor that handles both images and videos with enhanced detection"""
-    if media_file is None:
-        return None, "No file uploaded", None, format_violations_as_text([])
-    
-    file_path = media_file.name
-    file_extension = os.path.splitext(file_path)[1].lower()
-    
-    # Image file extensions
-    image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp']
-    # Video file extensions  
-    video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv', '.webm']
-    
-    if file_extension in image_extensions:
-        logger.info(f"Processing image file: {file_path}")
-        return await process_image(file_path, progress)
-    elif file_extension in video_extensions:
-        logger.info(f"Processing video file: {file_path}")
-        return await process_video(file_path, frame_skip, progress)
-    else:
-        error_msg = f"Unsupported file format: {file_extension}. Supported formats: {image_extensions + video_extensions}"
-        logger.error(error_msg)
-        return None, error_msg, None, format_violations_as_text([])
-
 # --- RTSP Processing ---
 async def process_rtsp_stream(rtsp_url, max_frames=None, frame_skip=5, progress=gr.Progress()):
     global processing_active
@@ -1300,7 +1154,7 @@ async def process_rtsp_stream(rtsp_url, max_frames=None, frame_skip=5, progress=
         tracker = SafetyViolationDetector()
 
         tracker.reset_session()
-        logger.info("Starting new enhanced RTSP stream analysis session")
+        logger.info("Starting new RTSP stream analysis session")
 
         # Get Salesforce connection once at the beginning
         sf = None
@@ -1311,7 +1165,7 @@ async def process_rtsp_stream(rtsp_url, max_frames=None, frame_skip=5, progress=
                 logger.error(f"Could not connect to Salesforce at start: {e}")
        
         frames = []
-        max_display_frames = 15  # Increased for better visualization
+        max_display_frames = 10
         violation_count = 0
 
         progress(0, desc="Connecting to RTSP stream...")
@@ -1324,19 +1178,10 @@ async def process_rtsp_stream(rtsp_url, max_frames=None, frame_skip=5, progress=
                 continue
 
             progress_percent = min(100, (fc / (max_frames if max_frames else 100)) * 100)
-            progress(progress_percent / 100, desc=f"Enhanced processing frame {fc}")
+            progress(progress_percent / 100, desc=f"Processing frame {fc}")
 
-            # Enhanced preprocessing
             processed_frame = preprocess_frame(frame)
-            
-            # Enhanced YOLO detection
-            results = yolo_model.predict(
-                processed_frame,
-                conf=0.4,  # Lower confidence for better detection
-                iou=0.5,   # Adjusted IoU threshold
-                verbose=False,
-                save=False
-            )
+            results = yolo_model.predict(processed_frame)
 
             violations = tracker.detect_violations(results, frame)
 
@@ -1398,6 +1243,9 @@ async def process_rtsp_stream(rtsp_url, max_frames=None, frame_skip=5, progress=
             pdf_temp_path, pdf_sf_url = generate_and_upload_report_to_salesforce(sf, current_run_violations, new_sf_record_ids)
             if not pdf_temp_path:
                  logger.error("Failed to generate and upload Salesforce report.")
+        elif current_run_violations and not sf:
+            # Generate local PDF if no Salesforce
+            pdf_temp_path = generate_local_pdf_report(current_run_violations)
         elif not current_run_violations:
             logger.info("No violations detected, skipping report generation.")
         else:
@@ -1407,14 +1255,14 @@ async def process_rtsp_stream(rtsp_url, max_frames=None, frame_skip=5, progress=
             return "Processing cancelled.", frames, format_violations_as_text(current_run_violations), generate_heatmap(current_run_violations, generate=False), pdf_temp_path
 
         session_summary = tracker.get_session_summary()
-        logger.info(f"Enhanced RTSP analysis complete. Session summary: {session_summary}")
+        logger.info(f"RTSP analysis complete. Session summary: {session_summary}")
         logger.info(f"Total processing time: {time.time() - start_total:.2f}s")
 
-        status_message = f"Enhanced processing completed: {len(frames)} frames with {violation_count} unique violations. Persons tracked: {session_summary['total_persons']}"
+        status_message = f"Processed {len(frames)} frames with {violation_count} unique violations. Persons tracked: {session_summary['total_persons']}"
 
         return status_message, frames, format_violations_as_text(current_run_violations), generate_heatmap(current_run_violations, generate=False), pdf_temp_path
     except Exception as e:
-        logger.error(f"Enhanced RTSP processing error: {e}", exc_info=True)
+        logger.error(f"RTSP processing error: {e}", exc_info=True)
         error_message = f"RTSP processing failed: {str(e)}"
         return error_message, None, format_violations_as_text([]), None, None
     finally:
@@ -1425,15 +1273,13 @@ async def process_rtsp_stream(rtsp_url, max_frames=None, frame_skip=5, progress=
 # --- Other Functions ---
 def generate_status_message(has_violations, total_frames, processed_frames, duration,
                             violation_count, processing_time, actual_fps, session_summary=None):
-    base_message = f"""✅ ENHANCED ANALYSIS COMPLETED
+    base_message = f"""✅ ANALYSIS COMPLETED
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 📊 RESULTS:
 • Frames: {total_frames} (Processed: {processed_frames})
 • Duration: {duration:.2f}s
 • Processing Time: {processing_time:.2f}s
-• FPS: {actual_fps:.1f}
-• Enhanced detection algorithms applied
-• Precise violation visualization enabled"""
+• FPS: {actual_fps:.1f}"""
 
     if session_summary:
         base_message += f"""
@@ -1444,7 +1290,7 @@ def generate_status_message(has_violations, total_frames, processed_frames, dura
         return f"""{base_message}
 🚨 UNIQUE VIOLATIONS: {violation_count}
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Each violation precisely marked with enhanced visualization"""
+Each violation reported only once per person"""
     else:
         return f"""{base_message}
 ✅ NO VIOLATIONS DETECTED
@@ -1486,34 +1332,32 @@ def send_alert(violation):
 
 def format_violations_as_text(violations):
     if not violations:
-        return """🔍 ENHANCED SAFETY MONITORING STATUS
+        return """🔍 SAFETY MONITORING STATUS
 
 ✅ NO VIOLATIONS DETECTED
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 📊 Current Status: ALL CLEAR
 🕐 Last Updated: """ + datetime.now(IST).strftime('%Y-%m-%d %H:%M:%S IST') + """
-🎯 Detection Accuracy: >95% confidence (Enhanced)
-⚡ Response Time: <3 seconds
-🔍 Visualization: Precise violation marking enabled
+🎯 Detection Accuracy: >90% confidence
+⚡ Response Time: <5 seconds
 
-The enhanced system is actively monitoring for:
-• No Helmet violations (Head region focus)
-• Unsafe Distance violations (Precise measurement)
-• Unauthorized Area violations (Zone highlighting)
+The system is actively monitoring for:
+• No Helmet violations
+• Unsafe Distance violations  
+• Unauthorized Area violations
 
 All safety protocols are currently being followed."""
 
-    text = f"""🚨 ENHANCED SAFETY VIOLATION ALERTS
+    text = f"""🚨 SAFETY VIOLATION ALERTS
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 📊 UNIQUE VIOLATIONS DETECTED: {len(violations)}
-🔍 Enhanced Detection: Precise violation visualization enabled
 Note: Each violation type reported only once per person
 
 """
     for i, violation in enumerate(violations, 1):
-        severity_emoji = "🔴" if violation['severity'] == 'Critical' else "🟡" if violation['severity'] == 'High' else "🟠"
+        severity_emoji = "🔴" if violation['severity'] == 'Critical' else "🟡"
         text += f"""
 ┌─ ALERT #{i:02d} ─ {severity_emoji} {violation['violation_type'].upper()}
 │
@@ -1522,24 +1366,21 @@ Note: Each violation type reported only once per person
 ├─ 📍 Location: Site {violation['site_id']} | Camera {violation['camera_id']}
 ├─ 👷 Worker: {violation.get('worker_id', 'UNKNOWN')}
 ├─ 📸 Evidence: {violation['snapshot_url']}
-├─ 🎯 Enhanced: Precise violation marking applied
 │
 └─────────────────────────────────────────────��───\n"""
 
     text += f"""
 
-📈 ENHANCED SUMMARY STATISTICS:
+📈 SUMMARY STATISTICS:
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 • Total Violations: {len(violations)}
 • Critical: {sum(1 for v in violations if v['severity'] == 'Critical')}
-• High: {sum(1 for v in violations if v['severity'] == 'High')}
 • Moderate: {sum(1 for v in violations if v['severity'] == 'Moderate')}
 • Last Alert: {violations[-1]['timestamp'] if violations else 'N/A'}
 
-🔄 System Status: ENHANCED MONITORING ACTIVE
-⚡ Response Time: <3 seconds
-🎯 Detection Accuracy: >95% confidence
-🔍 Visualization: Precise violation marking enabled"""
+🔄 System Status: ACTIVELY MONITORING
+⚡ Response Time: <5 seconds
+🎯 Detection Accuracy: >90% confidence"""
     return text
    
 def generate_heatmap(violations, generate=True):
@@ -1552,7 +1393,7 @@ def generate_heatmap(violations, generate=True):
 
         plt.figure(figsize=(12, 8))
         sns.heatmap(heatmap_data, cmap='YlOrRd', annot=True, fmt='d')
-        plt.title("Enhanced Violation Analysis - Temporal Distribution")
+        plt.title("Unique Violations by Hour")
         plt.xlabel("Violation Type")
         plt.ylabel("Hour of Day")
 
@@ -1962,9 +1803,9 @@ enhanced_custom_css = """
 }
 """
 
-# --- Enhanced Gradio Interface ---
+# --- Gradio Interface ---
 with gr.Blocks(
-    title="Enhanced Safety Violation Detection using CCTV + AI",
+    title="Dynamic Safety Violation Detection using CCTV + AI",
     css=enhanced_custom_css,
     theme=gr.themes.Soft(
         primary_hue="blue",
@@ -2071,18 +1912,18 @@ with gr.Blocks(
     # Professional Header
     gr.HTML("""
         <div class="main-header">
-            <h1 class="header-title">🔍 Enhanced Safety Violation Detection using CCTV + AI</h1>
-            <p class="header-subtitle">Advanced Multi-Person Tracking with Precise Violation Visualization - Enhanced Detection Accuracy >95%</p>
+            <h1 class="header-title">🔍 Dynamic Safety Violation Detection using CCTV + AI</h1>
+            <p class="header-subtitle">Enhanced Multi-Person Tracking with Image & Video Analysis - Each violation type detected only once per person</p>
         </div>
     """)
    
     # Smart Media Analysis Section
-    gr.HTML('<div class="section-header">📷 Enhanced Smart Media Analysis</div>')
+    gr.HTML('<div class="section-header">📷 Smart Media Analysis (Images & Videos)</div>')
     with gr.Row():
         with gr.Column(scale=1):
             with gr.Group(elem_classes=["professional-card"]):
                 media_input = gr.File(
-                    label="📤 Upload Image or Video for Enhanced Safety Analysis",
+                    label="📤 Upload Image or Video for Safety Analysis",
                     file_types=["image", "video"],
                     elem_classes=["image-component"],
                     height=200
@@ -2092,55 +1933,55 @@ with gr.Blocks(
                     maximum=10,
                     step=1,
                     value=5,
-                    label="🎯 Frame Skip (Higher = Faster Processing, Lower = More Accurate)"
+                    label="Frame Skip (Higher = Faster Processing, Videos Only)"
                 )
                 with gr.Row():
                     media_button = gr.Button(
-                        "🔍 Analyze with Enhanced Detection",
+                        "🔍 Analyze Media",
                         variant="primary",
                         elem_classes=["btn-primary"],
                         size="lg"
                     )
    
     # Analysis Results Section
-    gr.HTML('<div class="section-header">📊 Enhanced Analysis Results & Precise Violation Visualization</div>')
+    gr.HTML('<div class="section-header">📊 Analysis Results & Violation Details</div>')
     with gr.Row():
         with gr.Column(scale=1):
             with gr.Group(elem_classes=["professional-card"]):
                 media_output = gr.Gallery(
-                    label="🖼️ Enhanced Media with Precise Violation Detection",
+                    label="🖼️ Processed Media with Detection Results",
                     elem_classes=["gallery-component"],
-                    height=280
+                    height=260
                 )
         with gr.Column(scale=1):
             with gr.Group(elem_classes=["professional-card"]):
                 media_status = gr.Textbox(
-                    label="📋 Enhanced Analysis Status",
+                    label="📋 Analysis Status",
                     elem_classes=["status-display"],
-                    lines=8,
-                    max_lines=10,
-                    value="📊 Enhanced Detection System Ready\n\nUpload an image/video and click 'Analyze with Enhanced Detection' to begin advanced safety violation detection with precise visualization.",
+                    lines=7,
+                    max_lines=9,
+                    value="📊 Awaiting Media Analysis\n\nUpload an image or video and click 'Analyze Media' to begin safety violation detection.\n\n• Images: Instant analysis\n• Videos: Frame-by-frame processing",
                     interactive=False
                 )
                 pdf_output = gr.File(
-                    label="📥 Download Enhanced Professional Report",
+                    label="📥 Download Professional Report",
                     elem_classes=["file-component"]
                 )
    
     # Violation Details Section
-    gr.HTML('<div class="section-header">🚨 Real-time Enhanced Violation Monitoring</div>')
+    gr.HTML('<div class="section-header">🚨 Real-time Violation Monitoring</div>')
     with gr.Group(elem_classes=["professional-card", "alert-panel"]):
         violation_log = gr.Textbox(
-            label="🚨 Real-time Enhanced Violation Details",
+            label="🚨 Real-time Violation Details",
             elem_classes=["status-display"],
-            lines=12,
-            max_lines=15,
+            lines=10,
+            max_lines=12,
             value=format_violations_as_text(recent_violations),
             interactive=False
         )
    
     # Live Stream Processing Section
-    gr.HTML('<div class="section-header">📹 Enhanced Live Stream Monitoring</div>')
+    gr.HTML('<div class="section-header">📹 Live Stream Monitoring</div>')
     with gr.Row():
         with gr.Column(scale=2):
             with gr.Group(elem_classes=["professional-card"]):
@@ -2150,16 +1991,9 @@ with gr.Blocks(
                     value=RTSP_URL_DEFAULT,
                     interactive=True
                 )
-                rtsp_frame_skip = gr.Slider(
-                    minimum=1,
-                    maximum=10,
-                    step=1,
-                    value=5,
-                    label="🎯 RTSP Frame Skip (Higher = Faster, Lower = More Accurate)"
-                )
                 with gr.Row():
                     rtsp_button = gr.Button(
-                        "📡 Start Enhanced Live Monitoring",
+                        "📡 Start Live Monitoring",
                         variant="primary",
                         elem_classes=["btn-primary"],
                         size="lg"
@@ -2171,73 +2005,73 @@ with gr.Blocks(
                         size="lg"
                     )
                 rtsp_status = gr.Textbox(
-                    label="📺 Enhanced Live Stream Processing Status",
+                    label="📺 Live Stream Processing Status",
                     elem_classes=["status-display"],
                     lines=6,
                     max_lines=8,
-                    value="📺 Enhanced RTSP Stream Processor Ready\n\nEnter an RTSP URL and click 'Start Enhanced Live Monitoring' to begin real-time monitoring with precise violation visualization.",
+                    value="📺 RTSP Stream Processor Ready\n\nEnter an RTSP URL and click 'Start Live Monitoring' to begin real-time monitoring.",
                     interactive=False
                 )
         with gr.Column(scale=3):
             with gr.Group(elem_classes=["professional-card"]):
                 rtsp_output = gr.Gallery(
-                    label="🎬 Enhanced Live Stream Frames & Precise Detection Results",
+                    label="🎬 Live Stream Frames & Detection Results",
                     elem_classes=["gallery-component"],
-                    height=380,
+                    height=360,
                     columns=3,
                     rows=2,
                     object_fit="cover"
                 )
    
     # Live Violation Log Section
-    gr.HTML('<div class="section-header">📊 Enhanced Live Violation Analytics</div>')
+    gr.HTML('<div class="section-header">📊 Live Violation Analytics</div>')
     with gr.Row():
         with gr.Column(scale=1):
             with gr.Group(elem_classes=["professional-card", "alert-panel"]):
                 rtsp_violation_log = gr.Textbox(
-                    label="🚨 Enhanced Live Violation Log",
+                    label="🚨 Live Violation Log",
                     elem_classes=["status-display"],
-                    lines=10,
-                    max_lines=12,
+                    lines=8,
+                    max_lines=10,
                     interactive=False
                 )
         with gr.Column(scale=1):
             with gr.Group(elem_classes=["professional-card", "analytics-panel"]):
                 heatmap_output = gr.Image(
-                    label="🔥 Enhanced Violation Heatmap - Temporal Analysis",
+                    label="🔥 Violation Heatmap - Temporal Analysis",
                     elem_classes=["image-component"],
-                    height=340
+                    height=320
                 )
                 rtsp_pdf_output = gr.File(
-                    label="📥 Download Enhanced RTSP Report",
+                    label="📥 Download RTSP Report",
                     elem_classes=["file-component"]
                 )
    
     # Professional Footer
     gr.HTML("""
         <div class="footer-info">
-            <h3>🛡️ Enhanced Safety Violation Detection using CCTV + AI</h3>
+            <h3>🛡️ Dynamic Safety Violation Detection using CCTV + AI</h3>
             <div class="feature-grid">
                 <div class="feature-item">
-                    <strong>🎯 Enhanced Detection</strong><br>
-                    Advanced YOLOv8 AI with >95% accuracy
+                    <strong>🎯 Real-time Detection</strong><br>
+                    Advanced YOLOv8 AI with >90% accuracy
                 </div>
                 <div class="feature-item">
                     <strong>⚡ Ultra-fast Response</strong><br>
-                    Alert generation in <3 seconds
+                    Alert generation in <5 seconds
                 </div>
                 <div class="feature-item">
-                    <strong>🔍 Precise Visualization</strong><br>
-                    Exact violation location marking
+                    <strong>📸 Image & Video Support</strong><br>
+                    Process both static images and video files
                 </div>
                 <div class="feature-item">
                     <strong>📱 Responsive Design</strong><br>
-                    Optimized for all devices
+                    Optimized for desktop, tablet & mobile
                 </div>
             </div>
             <div style="margin-top: 0.8rem; padding-top: 0.8rem; border-top: 0.5px solid rgba(255,255,255,0.2);">
                 <p style="margin: 0; font-size: 0.8rem; opacity: 0.7;">
-                    Enhanced Safety Violation Detection using CCTV + AI © 2025 - Precise Violation Visualization Enabled
+                    Dynamic Safety Violation Detection using CCTV + AI © 2025
                 </p>
             </div>
         </div>
@@ -2252,7 +2086,7 @@ with gr.Blocks(
 
     rtsp_button.click(
         fn=process_rtsp_stream,
-        inputs=[rtsp_url_input, gr.Number(value=None, visible=False), rtsp_frame_skip],
+        inputs=[rtsp_url_input],
         outputs=[rtsp_status, rtsp_output, rtsp_violation_log, heatmap_output, rtsp_pdf_output]
     )
     rtsp_cancel_btn.click(cancel_processing, outputs=[rtsp_status])