Update app.py

app.py

@@ -586,12 +586,13 @@ def process_video(
                     correct_dir_l1 = (curr_sign_l1 == L1_inside_sign)
                     
                     # Method 3: Close proximity check (catches near-misses)
-                    close_to_l1 = abs(curr_l1_dist) < 40  # within 40 pixels
-                    was_far_l1 = abs(prev_l1) > 20  # was at least 20 pixels away
+                    close_to_l1 = abs(curr_l1_dist) < 35  # within 40 pixels
+                    was_far_l1 = abs(prev_l1) > 40  # was at least 20 pixels away
                     moving_toward_l1 = abs(curr_l1_dist) < abs(prev_l1)  # getting closer
                     
                     # Trigger L1 crossing if ANY method detects it
-                    if (inter_l1 or (sign_change_l1 and correct_dir_l1)):
+                    if (inter_l1 or (sign_change_l1 and correct_dir_l1) or 
+                        (close_to_l1 and was_far_l1 and moving_toward_l1 and correct_dir_l1)):
                         if inside and not crossed_l1_flag.get(tid, False):
                             crossed_l1_flag[tid] = True
                             print(f"L1 crossed by ID {tid}")
@@ -617,7 +618,8 @@ def process_video(
                     
                     # Trigger L2 crossing if ANY method detects it
                     if (inter_l2 or 
-                        (sign_change_l2 and correct_dir_l2)):
+                        (sign_change_l2 and correct_dir_l2) or 
+                        (close_to_l2 and was_far_l2 and moving_toward_l2 and correct_dir_l2)):
                         # Count only if L1 was already crossed and not yet counted
                         if inside and crossed_l1_flag.get(tid, False) and not crossed_l2_counted.get(tid, False):
                             global_counter += 1
@@ -914,36 +916,197 @@ def process_video(
 
     df = pd.DataFrame(rows, columns=["Person","Time in","Time out","Time in queue (seconds)"])
     if len(df) > 0:
-        df.to_excel("person_times.xlsx", index=False)
+        df.to_excel("person_times_2.xlsx", index=False)
     else:
-        pd.DataFrame(columns=["Passenger","Time in","Time out","Time in queue (seconds)"]).to_excel("person_times.xlsx", index=False)
+        pd.DataFrame(columns=["Passenger","Time in","Time out","Time in queue (seconds)"]).to_excel("person_times_2.xlsx", index=False)
 
     print("\nFinished. Output:", os.path.abspath(output_video_path))
-    print("Saved times:", os.path.abspath("person_times.xlsx"))
+    print("Saved times:", os.path.abspath("person_times_2.xlsx"))
+
+# # ---------------- Runner
+# if __name__ == "__main__":
+#     CONFIG = {
+#         'input_video_path': "sample_vid_o.mp4",
+#         'output_video_path': "output24.avi",
+#         'model_name': "yolo11x.pt",
+#         'head_model_name': "head_detection_single_video_best.pt",
+#         'conf_threshold': 0.3,
+#         'img_size': 1280,
+#         'use_gpu': True,
+#         'enhance_frames': False,
+#         'smooth_bbox_tracks': True,
+#         'missing_timeout': 3.0
+#     }
+#     process_video(
+#         input_video_path = CONFIG['input_video_path'],
+#         output_video_path = CONFIG['output_video_path'],
+#         model_name = CONFIG['model_name'],
+#         head_model_name = CONFIG['head_model_name'],
+#         conf_threshold = CONFIG['conf_threshold'],
+#         img_size = CONFIG['img_size'],
+#         use_gpu = CONFIG['use_gpu'],
+#         enhance_frames = CONFIG['enhance_frames'],
+#         smooth_bbox_tracks = CONFIG['smooth_bbox_tracks'],
+#         missing_timeout = CONFIG['missing_timeout']
+#     )
+
+
+# ---------------- Gradio Interface
+import gradio as gr
+import tempfile
+import shutil
+
+def gradio_process_video(input_video, conf_threshold=0.3, missing_timeout=3.0):
+    """
+    Wrapper function for Gradio interface
+    """
+    try:
+        # Create temporary directory for outputs
+        temp_dir = tempfile.mkdtemp()
+        
+        # Define output paths
+        output_video_path = os.path.join(temp_dir, "output_tracking.mp4")
+        excel_path = os.path.join(temp_dir, "person_times.xlsx")
+        
+        # Copy the excel file path for the process_video function to use
+        original_excel = "person_times_2.xlsx"
+        
+        # Run the processing
+        CONFIG = {
+            'input_video_path': input_video,
+            'output_video_path': output_video_path,
+            'model_name': "yolo11x.pt",
+            'head_model_name': "head_detection_single_video_best.pt",
+            'conf_threshold': float(conf_threshold),
+            'img_size': 1280,
+            'use_gpu': torch.cuda.is_available(),
+            'enhance_frames': False,
+            'smooth_bbox_tracks': True,
+            'missing_timeout': float(missing_timeout)
+        }
+        
+        process_video(
+            input_video_path=CONFIG['input_video_path'],
+            output_video_path=CONFIG['output_video_path'],
+            model_name=CONFIG['model_name'],
+            head_model_name=CONFIG['head_model_name'],
+            conf_threshold=CONFIG['conf_threshold'],
+            img_size=CONFIG['img_size'],
+            use_gpu=CONFIG['use_gpu'],
+            enhance_frames=CONFIG['enhance_frames'],
+            smooth_bbox_tracks=CONFIG['smooth_bbox_tracks'],
+            missing_timeout=CONFIG['missing_timeout']
+        )
+        
+        # Copy the generated excel file to temp directory
+        if os.path.exists(original_excel):
+            shutil.copy(original_excel, excel_path)
+        
+        return output_video_path, excel_path
+        
+    except Exception as e:
+        print(f"Error processing video: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return None, None
+
+# Create Gradio interface
+with gr.Blocks(title="Queue Tracking System") as demo:
+    gr.Markdown(
+        """
+        # 🎯 Queue Tracking & Analytics System
+        
+        Upload a video to track people in a defined polygon area. The system will:
+        - Track people entering and exiting the zone
+        - Count directional crossings through L1 and L2 lines
+        - Calculate time spent in queue
+        - Measure travel distance
+        - Detect both full body and head-only detections
+        
+        **Note:** Processing may take several minutes depending on video length.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            video_input = gr.Video(
+                label="Upload Video",
+                format="mp4"
+            )
+            
+            conf_threshold = gr.Slider(
+                minimum=0.1,
+                maximum=0.9,
+                value=0.3,
+                step=0.05,
+                label="Detection Confidence Threshold",
+                info="Lower values detect more objects but may include false positives"
+            )
+            
+            missing_timeout = gr.Slider(
+                minimum=1.0,
+                maximum=10.0,
+                value=3.0,
+                step=0.5,
+                label="Missing Timeout (seconds)",
+                info="How long to wait before considering a person has left the zone"
+            )
+            
+            process_btn = gr.Button("🚀 Process Video", variant="primary", size="lg")
+        
+        with gr.Column():
+            video_output = gr.Video(
+                label="Processed Video with Tracking",
+                format="mp4"
+            )
+            
+            excel_output = gr.File(
+                label="Download Excel Report",
+                file_types=[".xlsx"]
+            )
+            
+            gr.Markdown(
+                """
+                ### 📊 Output Information:
+                - **Processed Video**: Shows tracking overlay with IDs, polygon area, and crossing lines
+                - **Excel Report**: Contains entry/exit times and queue duration for each person
+                """
+            )
+    
+    gr.Markdown(
+        """
+        ---
+        ### 🔧 Technical Details:
+        - Uses YOLO11x for person detection
+        - Custom head detection model for occlusion handling
+        - Homographic transformation for accurate spatial mapping
+        - ByteTrack for robust ID tracking
+        - Directional crossing detection (L1 → L2)
+        """
+    )
+    
+    # Connect the button to the processing function
+    process_btn.click(
+        fn=gradio_process_video,
+        inputs=[video_input, conf_threshold, missing_timeout],
+        outputs=[video_output, excel_output]
+    )
+    
+    # Add examples if you have sample videos
+    gr.Examples(
+        examples=[
+            ["sample_vid_o.mp4", 0.3, 3.0],
+        ],
+        inputs=[video_input, conf_threshold, missing_timeout],
+        outputs=[video_output, excel_output],
+        fn=gradio_process_video,
+        cache_examples=False,
+    )
 
-# ---------------- Runner
+# Launch the app
 if __name__ == "__main__":
-    CONFIG = {
-        'input_video_path': "sample_vid.mp4",
-        'output_video_path': "output23.avi",
-        'model_name': "yolo11x.pt",
-        'head_model_name': "head_detection_single_video_best.pt",
-        'conf_threshold': 0.3,
-        'img_size': 1280,
-        'use_gpu': True,
-        'enhance_frames': False,
-        'smooth_bbox_tracks': True,
-        'missing_timeout': 3.0
-    }
-    process_video(
-        input_video_path = CONFIG['input_video_path'],
-        output_video_path = CONFIG['output_video_path'],
-        model_name = CONFIG['model_name'],
-        head_model_name = CONFIG['head_model_name'],
-        conf_threshold = CONFIG['conf_threshold'],
-        img_size = CONFIG['img_size'],
-        use_gpu = CONFIG['use_gpu'],
-        enhance_frames = CONFIG['enhance_frames'],
-        smooth_bbox_tracks = CONFIG['smooth_bbox_tracks'],
-        missing_timeout = CONFIG['missing_timeout']
+    demo.launch(
+        share=False,  # Set to True if you want a temporary public link
+        server_name="0.0.0.0",  # Important for Hugging Face Spaces
+        server_port=7860  # Default port for HF Spaces
     )