Update app.py

app.py

@@ -18,6 +18,15 @@ from scipy.ndimage import gaussian_filter1d
 from ultralytics import YOLO
 import os
 
+import platform
+import sys
+
+# Mac-specific optimizations
+if platform.system() == "Darwin":
+    import os
+    os.environ['PYTORCH_ENABLE_MPS_FALLBACK'] = '1'
+    os.environ['OMP_NUM_THREADS'] = '1'
+
 # ---------------- Points in image (given) - adjust if needed
 A = (440.0, 829.0)
 B = (883.0, 928.0)
@@ -288,10 +297,12 @@ def process_video(
     prev_foot = {}           # {id: (x,y)} previous foot coordinate (image space)
     crossed_l1_flag = {}     # {id: bool} whether this id has crossed L1 (in required direction) and not yet used to count
     crossed_l2_counted = {}  # {id: bool} whether this id has already triggered the global count by crossing L2 after L1
+    prev_l1_dist = {}  # Track distance to L1
+    prev_l2_dist = {}  # Track distance to L2
 
     global_counter = 0       # counts completed L1->L2 sequences
     completed_times = []     # for avg time taken
-
+    sequential_entries = []
     cap = cv2.VideoCapture(input_video_path)
     if not cap.isOpened():
         raise RuntimeError("Cannot open input video: " + input_video_path)
@@ -302,8 +313,10 @@ def process_video(
 
     out_w = width + RIGHT_PANEL_W
     out_h = height
-    fourcc = cv2.VideoWriter_fourcc(*'MJPG')
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # or 'H264' or 'avc1'
+    output_video_path = "output23.mp4"  # Must be .mp4 extension
     writer = cv2.VideoWriter(output_video_path, fourcc, fps, (out_w, out_h))
+
     if not writer.isOpened():
         raise RuntimeError("Failed to open VideoWriter. Try different codec or path.")
 
@@ -502,39 +515,130 @@ def process_video(
                 current_pt = (fx, fy)
 
                 # Crossing detection for L1
-                if prev_pt is not None:
-                    # check intersection with L1
+                # if prev_pt is not None:
+                #     # check intersection with L1
+                #     inter_l1 = segment_intersects(prev_pt, current_pt, L1_p1, L1_p2)
+                #     if inter_l1:
+                #         # check direction: we want prev_sign != curr_sign and curr_sign == inside sign
+                #         prev_sign = np.sign(signed_dist_to_line(prev_pt, L1_coeff))
+                #         curr_sign = np.sign(signed_dist_to_line(current_pt, L1_coeff))
+                #         if prev_sign == 0:
+                #             prev_sign = -curr_sign if curr_sign != 0 else 1.0
+                #         if curr_sign == 0:
+                #             curr_sign = prev_sign
+                #         if prev_sign != curr_sign and curr_sign == L1_inside_sign:
+                #             # crossed L1 in correct direction (outside -> inside)
+                #             crossed_l1_flag[tid] = True
+
+                #     # check intersection with L2
+                #     inter_l2 = segment_intersects(prev_pt, current_pt, L2_p1, L2_p2)
+                #     if inter_l2:
+                #         prev_sign = np.sign(signed_dist_to_line(prev_pt, L2_coeff))
+                #         curr_sign = np.sign(signed_dist_to_line(current_pt, L2_coeff))
+                #         if prev_sign == 0:
+                #             prev_sign = -curr_sign if curr_sign != 0 else 1.0
+                #         if curr_sign == 0:
+                #             curr_sign = prev_sign
+                #         if prev_sign != curr_sign and curr_sign == L2_inside_sign:
+                #             # crossed L2 in correct direction; if previously crossed L1 and not yet counted => count
+                #             if crossed_l1_flag.get(tid, False) and not crossed_l2_counted.get(tid, False):
+                #                 global_counter += 1
+                #                 crossed_l2_counted[tid] = True
+                #                 # Record the sequential entry
+                #                 entry_vid_time = first_entry_vid.get(tid, vid_seconds)
+                #                 sequential_entries.append({
+                #                     'person_num': global_counter,
+                #                     'tid': tid,
+                #                     'entry_time': entry_vid_time,
+                #                     'exit_time': None,
+                #                     'duration': None
+                #                 })
+                #                 # once person completed crossing sequence, we keep their travel/time records intact
+                # update prev_foot
+                # prev_foot[tid] = current_pt
+
+
+                # maintain prev_foot for intersection tests
+                prev_pt = prev_foot.get(tid, None)
+                current_pt = (fx, fy)
+
+                # Calculate signed distances to both lines
+                curr_l1_dist = signed_dist_to_line(current_pt, L1_coeff)
+                curr_l2_dist = signed_dist_to_line(current_pt, L2_coeff)
+
+                # Robust crossing detection
+                if prev_pt is not None and tid in prev_l1_dist and tid in prev_l2_dist:
+                    prev_l1 = prev_l1_dist[tid]
+                    prev_l2 = prev_l2_dist[tid]
+                    
+                    # === L1 CROSSING (3 detection methods) ===
+                    # Method 1: Segment intersection (current method)
                     inter_l1 = segment_intersects(prev_pt, current_pt, L1_p1, L1_p2)
-                    if inter_l1:
-                        # check direction: we want prev_sign != curr_sign and curr_sign == inside sign
-                        prev_sign = np.sign(signed_dist_to_line(prev_pt, L1_coeff))
-                        curr_sign = np.sign(signed_dist_to_line(current_pt, L1_coeff))
-                        if prev_sign == 0:
-                            prev_sign = -curr_sign if curr_sign != 0 else 1.0
-                        if curr_sign == 0:
-                            curr_sign = prev_sign
-                        if prev_sign != curr_sign and curr_sign == L1_inside_sign:
-                            # crossed L1 in correct direction (outside -> inside)
+                    
+                    # Method 2: Sign change in distance
+                    prev_sign_l1 = np.sign(prev_l1)
+                    curr_sign_l1 = np.sign(curr_l1_dist)
+                    if prev_sign_l1 == 0:
+                        prev_sign_l1 = 1.0
+                    if curr_sign_l1 == 0:
+                        curr_sign_l1 = prev_sign_l1
+                    sign_change_l1 = (prev_sign_l1 != curr_sign_l1)
+                    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
+                    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 inside and not crossed_l1_flag.get(tid, False):
                             crossed_l1_flag[tid] = True
+                            print(f"L1 crossed by ID {tid}")
 
-                    # check intersection with L2
+                    # === L2 CROSSING (3 detection methods) ===
+                    # Method 1: Segment intersection
                     inter_l2 = segment_intersects(prev_pt, current_pt, L2_p1, L2_p2)
-                    if inter_l2:
-                        prev_sign = np.sign(signed_dist_to_line(prev_pt, L2_coeff))
-                        curr_sign = np.sign(signed_dist_to_line(current_pt, L2_coeff))
-                        if prev_sign == 0:
-                            prev_sign = -curr_sign if curr_sign != 0 else 1.0
-                        if curr_sign == 0:
-                            curr_sign = prev_sign
-                        if prev_sign != curr_sign and curr_sign == L2_inside_sign:
-                            # crossed L2 in correct direction; if previously crossed L1 and not yet counted => count
-                            if crossed_l1_flag.get(tid, False) and not crossed_l2_counted.get(tid, False):
-                                global_counter += 1
-                                crossed_l2_counted[tid] = True
-                                # once person completed crossing sequence, we keep their travel/time records intact
-                # update prev_foot
+                    
+                    # Method 2: Sign change in distance
+                    prev_sign_l2 = np.sign(prev_l2)
+                    curr_sign_l2 = np.sign(curr_l2_dist)
+                    if prev_sign_l2 == 0:
+                        prev_sign_l2 = 1.0
+                    if curr_sign_l2 == 0:
+                        curr_sign_l2 = prev_sign_l2
+                    sign_change_l2 = (prev_sign_l2 != curr_sign_l2)
+                    correct_dir_l2 = (curr_sign_l2 == L2_inside_sign)
+                    
+                    # Method 3: Close proximity check
+                    close_to_l2 = abs(curr_l2_dist) < 40
+                    was_far_l2 = abs(prev_l2) > 20
+                    moving_toward_l2 = abs(curr_l2_dist) < abs(prev_l2)
+                    
+                    # Trigger L2 crossing if ANY method detects it
+                    if (inter_l2 or 
+                        (sign_change_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
+                            crossed_l2_counted[tid] = True
+                            print(f"✓ COUNTED: ID {tid} | Global count now: {global_counter}")
+                            
+                            entry_vid_time = first_entry_vid.get(tid, vid_seconds)
+                            sequential_entries.append({
+                                'person_num': global_counter,
+                                'tid': tid,
+                                'entry_time': entry_vid_time,
+                                'exit_time': None,
+                                'duration': None
+                            })
+
+                # Update distance tracking for next frame
+                prev_l1_dist[tid] = curr_l1_dist
+                prev_l2_dist[tid] = curr_l2_dist
                 prev_foot[tid] = current_pt
 
+                
                 if inside and not prev:
                     inside_state[tid] = True
                     if tid not in entry_time:
@@ -673,9 +777,17 @@ def process_video(
                     inside_state[tid] = False
                     if tid in entry_time:
                         accumulated_time[tid] += now - entry_time[tid]
-                        # record last exit time in video seconds (use last seen time)
-                        last_exit_vid[tid] = ls - start_time
+                        exit_vid_time = ls - start_time
+                        last_exit_vid[tid] = exit_vid_time
                         completed_times.append(accumulated_time[tid])
+                        
+                        # Update sequential entry exit time
+                        for entry in sequential_entries:
+                            if entry['tid'] == tid and entry['exit_time'] is None:
+                                entry['exit_time'] = exit_vid_time
+                                entry['duration'] = accumulated_time[tid]
+                                break
+                        
                         entry_time.pop(tid, None)
                 else:
                     # within occlusion grace window -> keep inside state
@@ -771,8 +883,17 @@ def process_video(
     end_t = time.time()
     for tid in list(entry_time.keys()):
         accumulated_time[tid] += end_t - entry_time[tid]
-        last_exit_vid[tid] = last_seen.get(tid, end_t) - start_time
+        exit_vid_time = last_seen.get(tid, end_t) - start_time
+        last_exit_vid[tid] = exit_vid_time
         completed_times.append(accumulated_time[tid])
+        
+        # Update sequential entry exit time
+        for entry in sequential_entries:
+            if entry['tid'] == tid and entry['exit_time'] is None:
+                entry['exit_time'] = exit_vid_time
+                entry['duration'] = accumulated_time[tid]
+                break
+        
         entry_time.pop(tid, None)
         inside_state[tid] = False
 
@@ -780,19 +901,18 @@ def process_video(
     writer.release()
 
     # export excel (only >0)
+    # export excel with sequential person numbers
     rows = []
-    for tid, tot in accumulated_time.items():
-        if tot <= 0:
-            continue
-        tin = first_entry_vid.get(tid, 0.0)
-        tout = last_exit_vid.get(tid, tin)
-        rows.append({
-            "Passenger": int(tid),
-            "Time in": fmt(tin),
-            "Time out": fmt(tout),
-            "Time in queue (seconds)": round(float(tot), 2)
-        })
-    df = pd.DataFrame(rows, columns=["Passenger","Time in","Time out","Time in queue (seconds)"])
+    for entry in sequential_entries:
+        if entry['exit_time'] is not None and entry['duration'] is not None and entry['duration'] > 0:
+            rows.append({
+                "Person": entry['person_num'],
+                "Time in": fmt(entry['entry_time']),
+                "Time out": fmt(entry['exit_time']),
+                "Time in queue (seconds)": round(float(entry['duration']), 2)
+            })
+
+    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)
     else:
@@ -805,7 +925,7 @@ def process_video(
 if __name__ == "__main__":
     CONFIG = {
         'input_video_path': "sample_vid.mp4",
-        'output_video_path': "output22.avi",
+        'output_video_path': "output23.avi",
         'model_name': "yolo11x.pt",
         'head_model_name': "head_detection_single_video_best.pt",
         'conf_threshold': 0.3,