Update app.py

app.py

@@ -7,144 +7,144 @@ import plotly.graph_objects as go
 from collections import defaultdict
 import time
 import requests
-from PIL import Image
-import io
 import pandas as pd
+from scipy.spatial import distance
+
+# --- Configuration & Initialization ---
 
 # Page configuration
 st.set_page_config(
-    page_title="People & Vehicle Counter",
-    page_icon="🚗",
+    page_title="YOLOv8 Object Tracking & Counter",
+    page_icon="🤖",
     layout="wide"
 )
 
 # Title and description
-st.title("🚗 People & Vehicle Counter")
+st.title("🚦 Smart Object Traffic Analyzer (YOLOv8)")
 st.markdown("""
-Upload a video or provide a video URL to count people and vehicles in real-time using YOLOv8.
-This app is useful for traffic monitoring, retail analytics, and crowd management.
+A professional application for real-time **tracking and counting** of people and vehicles in video streams. 
+It uses YOLOv8 for detection and a simple tracking algorithm to count unique objects crossing a user-defined line.
 """)
 
-# Sidebar for settings
+# COCO Class Names (Corrected for standard YOLOv8)
+COCO_CLASS_NAMES = {
+    0: "person", 1: "bicycle", 2: "car", 3: "motorcycle", 4: "airplane", 
+    5: "bus", 6: "train", 7: "truck", 8: "boat", 9: "traffic light", 
+    # ... other classes
+}
+
+# Mapping of checkboxed objects to their standard COCO Class IDs
+CLASS_MAPPING = {
+    "Person": 0,
+    "Bicycle": 1,
+    "Car": 2,
+    "Motorcycle": 3,
+    "Bus": 5,
+    "Truck": 7,
+}
+
+# Initialize session state for tracking
+if 'processed_data' not in st.session_state:
+    st.session_state.processed_data = {
+        'total_counts': defaultdict(int),
+        'frame_counts': [],
+        'processed_video': None,
+        'processing_complete': False,
+        'tracked_objects': {}, # Unique ID: {'class': str, 'last_centroid': (x, y), 'counted': bool}
+    }
+
+# --- Sidebar for Settings ---
 with st.sidebar:
-    st.header("⚙️ Settings")
+    st.header("⚙️ Configuration Settings")
+    
+    # Model Selection
+    st.subheader("Model & Detection")
+    model_name = st.selectbox("Select YOLO Model", options=['yolov8n.pt', 'yolov8s.pt'], help="Nano (n) is fast, Small (s) is more accurate.")
     
     # Confidence threshold
     confidence = st.slider(
-        "Detection Confidence",
-        min_value=0.1,
-        max_value=1.0,
-        value=0.25,
-        step=0.05,
-        help="Higher values reduce false positives but might miss some objects"
+        "Detection Confidence Threshold",
+        min_value=0.1, max_value=1.0, value=0.40, step=0.05,
+        help="Minimum confidence to consider a detection valid."
     )
     
     # Object classes to detect
-    st.subheader("Objects to Count")
-    count_person = st.checkbox("Person", value=True)
-    count_car = st.checkbox("Car", value=True)
-    count_bus = st.checkbox("Bus", value=False)
-    count_truck = st.checkbox("Truck", value=False)
-    count_motorcycle = st.checkbox("Motorcycle", value=False)
-    count_bicycle = st.checkbox("Bicycle", value=False)
+    st.subheader("Objects for Counting")
+    selected_classes_ui = {}
+    for name, id in CLASS_MAPPING.items():
+        # Default True for Person and Car, False otherwise
+        default_val = name in ["Person", "Car"]
+        selected_classes_ui[name] = st.checkbox(name, value=default_val)
     
     # Line intersection for counting
-    st.subheader("Counting Line")
-    show_line = st.checkbox("Show counting line", value=True)
+    st.subheader("Counting Line Settings")
+    show_line = st.checkbox("Show crossing line", value=True)
     line_position = st.slider(
-        "Line position (%)",
-        min_value=0,
-        max_value=100,
-        value=50,
-        help="Vertical line position for counting object crossings"
+        "Line Position (Vertical % from left)",
+        min_value=10, max_value=90, value=50,
+        help="Line position for counting objects that cross it."
     )
     
     # Processing options
-    st.subheader("Processing Options")
+    st.subheader("Performance Options")
     process_every_nth = st.slider(
-        "Process every Nth frame",
-        min_value=1,
-        max_value=10,
-        value=3,
-        help="Higher values speed up processing but reduce accuracy"
+        "Frame Skip (Process every Nth frame)",
+        min_value=1, max_value=10, value=2,
+        help="Higher values significantly speed up processing but reduce tracking smoothness."
     )
     
     max_frames = st.number_input(
-        "Maximum frames to process",
-        min_value=10,
-        max_value=1000,
-        value=200,
-        help="Limit processing for long videos"
+        "Maximum Frames to Analyze",
+        min_value=10, max_value=5000, value=500,
+        help="Limits the processing duration for long videos. Set to a very high number (e.g., 99999) for full video."
     )
 
-# Initialize session state
-if 'total_counts' not in st.session_state:
-    st.session_state.total_counts = defaultdict(int)
-if 'frame_counts' not in st.session_state:
-    st.session_state.frame_counts = []
-if 'processing_complete' not in st.session_state:
-    st.session_state.processing_complete = False
-if 'processed_video' not in st.session_state:
-    st.session_state.processed_video = None
+# --- Helper Functions ---
 
-# COCO class names for YOLO (common objects)
-CLASS_NAMES = {
-    0: "person", 1: "bicycle", 2: "car", 3: "motorcycle", 
-    5: "bus", 7: "truck", 64: "chair"  # Note: YOLOv8 uses different indices
-}
+@st.cache_resource
+def load_model(model_path):
+    """Caches the YOLO model loading."""
+    return YOLO(model_path)
 
-# Map our checkboxes to class IDs
-def get_selected_classes():
-    selected_classes = []
-    class_mapping = {
-        "person": 0,
-        "bicycle": 2,
-        "car": 2,
-        "motorcycle": 3,
-        "bus": 5,
-        "truck": 7
-    }
-    
-    if count_person:
-        selected_classes.append(0)
-    if count_bicycle:
-        selected_classes.append(1)
-    if count_car:
-        selected_classes.append(2)
-    if count_motorcycle:
-        selected_classes.append(3)
-    if count_bus:
-        selected_classes.append(5)
-    if count_truck:
-        selected_classes.append(7)
-    
-    return selected_classes
+def get_selected_class_ids():
+    """Returns a list of COCO class IDs selected by the user."""
+    return [CLASS_MAPPING[name] for name, is_selected in selected_classes_ui.items() if is_selected]
 
-# Load YOLO model with caching
-@st.cache_resource
-def load_model():
-    return YOLO('yolov8n.pt')  # Using nano model for speed
+# --- Core Processing Function (with simple tracking and crossing logic) ---
 
-# Function to process video
-def process_video(video_path, selected_classes):
-    model = load_model()
-    
+def process_video(video_path, selected_class_ids, model_path):
+    """
+    Processes the video, performs object detection/tracking, and counts line crossings.
+    """
+    model = load_model(model_path)
     cap = cv2.VideoCapture(video_path)
+    
+    # Video properties
     fps = int(cap.get(cv2.CAP_PROP_FPS))
     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     
-    # Initialize video writer
+    if total_frames > max_frames:
+        st.warning(f"Video is being processed for the first {max_frames} frames only (configurable in sidebar).")
+        
+    # Setup video writer (Using a smaller size for web-friendliness if possible)
     temp_output = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
     output_path = temp_output.name
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    # mp4v or XVID is generally compatible. mp4v preferred for browser.
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v') 
+    out = cv2.VideoWriter(output_path, fourcc, fps / process_every_nth, (width, height))
+    
+    # Initialize state variables for the loop
+    current_state = st.session_state.processed_data
+    current_state['total_counts'] = defaultdict(int)
+    current_state['frame_counts'] = []
+    current_state['tracked_objects'] = {} # ID: {'class': str, 'last_centroid': (x, y), 'counted': bool}
     
-    # Reset counts
-    st.session_state.total_counts = defaultdict(int)
-    st.session_state.frame_counts = []
+    # Define counting line
+    line_x = int(width * line_position / 100)
     
-    # Progress bar
+    # UI Elements for progress
     progress_bar = st.progress(0)
     status_text = st.empty()
     
@@ -153,50 +153,111 @@ def process_video(video_path, selected_classes):
     
     while cap.isOpened():
         ret, frame = cap.read()
+        
+        # Stop condition
         if not ret or processed_frames >= max_frames:
             break
         
         frame_count += 1
         
-        # Process only every nth frame
+        # Skip frames for performance (still write the frame for a continuous video)
         if frame_count % process_every_nth != 0:
-            out.write(frame)
+            # We don't write the skipped frame because we want the output video 
+            # to reflect the lower frame rate for smaller size and faster processing.
             continue
         
-        # Run YOLO inference
-        results = model(frame, conf=confidence, classes=selected_classes, verbose=False)
+        # --- YOLO Detection ---
+        # NOTE: Using tracker="bytetrack.yaml" for better tracking. Requires ultralytics>=8.0.198
+        # However, for simplicity and dependency management, we will use simple centroid tracking.
+        results = model.track(
+            frame, 
+            conf=confidence, 
+            classes=selected_class_ids, 
+            persist=True, 
+            tracker="bytetrack.yaml", # Use YOLO's built-in tracking!
+            verbose=False
+        )
+        
+        annotated_frame = frame.copy()
         
-        # Draw results
-        annotated_frame = results[0].plot()
+        # Current frame counts
+        current_frame_counts = defaultdict(int)
         
-        # Count objects
-        frame_counts = defaultdict(int)
-        for box in results[0].boxes:
-            cls_id = int(box.cls[0])
-            class_name = CLASS_NAMES.get(cls_id, f"class_{cls_id}")
-            frame_counts[class_name] += 1
-            st.session_state.total_counts[class_name] += 1
+        # --- Tracking and Counting Logic ---
+        if results and results[0].boxes.id is not None:
+            boxes = results[0].boxes.xyxy.cpu().numpy().astype(int)
+            track_ids = results[0].boxes.id.cpu().numpy().astype(int)
+            class_ids = results[0].boxes.cls.cpu().numpy().astype(int)
+            
+            for box, track_id, class_id in zip(boxes, track_ids, class_ids):
+                x1, y1, x2, y2 = box
+                
+                # Calculate centroid
+                centroid_x = (x1 + x2) // 2
+                centroid_y = (y1 + y2) // 2
+                centroid = (centroid_x, centroid_y)
+                
+                class_name = COCO_CLASS_NAMES.get(class_id, "Unknown")
+                current_frame_counts[class_name] += 1
+                
+                # Update/Initialize tracked object
+                if track_id not in current_state['tracked_objects']:
+                    # New object detected
+                    current_state['tracked_objects'][track_id] = {
+                        'class': class_name, 
+                        'last_centroid': centroid, 
+                        'counted': False
+                    }
+                else:
+                    # Existing object - Check for line crossing
+                    obj_data = current_state['tracked_objects'][track_id]
+                    prev_x = obj_data['last_centroid'][0]
+                    
+                    if not obj_data['counted']:
+                        # Crossing logic: object crossed the line from one side to the other
+                        if (prev_x < line_x and centroid_x >= line_x) or \
+                           (prev_x > line_x and centroid_x <= line_x):
+                            
+                            # Object crossed the line!
+                            current_state['total_counts'][class_name] += 1
+                            obj_data['counted'] = True # Count only once
+                            
+                    # Update the object's last known position
+                    obj_data['last_centroid'] = centroid
+                    
+                # Draw bounding box, track ID, and centroid
+                cv2.rectangle(annotated_frame, (x1, y1), (x2, y2), (255, 0, 0), 2)
+                cv2.circle(annotated_frame, centroid, 5, (0, 0, 255), -1)
+                
+                label = f"ID:{track_id} {class_name}"
+                cv2.putText(annotated_frame, label, (x1, y1 - 10), 
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
         
-        # Store frame counts for chart
-        st.session_state.frame_counts.append({
-            'frame': processed_frames,
-            **frame_counts
-        })
+        # --- Visualization & Logging ---
         
-        # Draw counting line if enabled
+        # Draw counting line
         if show_line:
-            line_x = int(width * line_position / 100)
-            cv2.line(annotated_frame, (line_x, 0), (line_x, height), (0, 255, 255), 2)
+            line_color = (0, 255, 255) # Cyan
+            cv2.line(annotated_frame, (line_x, 0), (line_x, height), line_color, 2)
+            
+            # Label for the line
+            cv2.putText(annotated_frame, "COUNTING LINE", (line_x + 5, 20), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, line_color, 2)
         
-        # Add counter text
+        # Add total counter text
         y_offset = 30
-        for obj_type, count in frame_counts.items():
+        for obj_type, count in current_state['total_counts'].items():
             cv2.putText(annotated_frame, 
-                       f"{obj_type}: {count}", 
-                       (10, y_offset), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 
-                       0.7, (0, 255, 0), 2)
-            y_offset += 25
+                        f"TOTAL {obj_type.upper()}: {count}", 
+                        (width - 300, y_offset), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+            y_offset += 35
+
+        # Store frame counts for chart (count of *objects in frame*, not crossings)
+        frame_data = {'frame': processed_frames * process_every_nth}
+        for name in CLASS_MAPPING.keys():
+             frame_data[name.lower()] = current_frame_counts.get(name.lower(), 0)
+        current_state['frame_counts'].append(frame_data)
         
         # Write frame to output video
         out.write(annotated_frame)
@@ -205,44 +266,69 @@ def process_video(video_path, selected_classes):
         # Update progress
         progress = min(processed_frames / max_frames, 1.0)
         progress_bar.progress(progress)
-        status_text.text(f"Processing frame {processed_frames}/{max_frames}")
+        status_text.text(f"Analyzing Frame {frame_count}/{total_frames} (Processed {processed_frames})")
     
+    # --- Cleanup ---
     cap.release()
     out.release()
     
-    st.session_state.processing_complete = True
-    st.session_state.processed_video = output_path
+    # Update global state
+    current_state['processing_complete'] = True
+    current_state['processed_video'] = output_path
+    st.session_state.processed_data = current_state
     
     return output_path
 
 # Function to download video from URL
+@st.cache_data
 def download_video_from_url(url):
+    """Downloads video from URL to a temporary file."""
     try:
-        response = requests.get(url, stream=True)
-        if response.status_code == 200:
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
-            for chunk in response.iter_content(chunk_size=8192):
-                temp_file.write(chunk)
-            temp_file.close()
-            return temp_file.name
-        else:
-            st.error(f"Failed to download video. Status code: {response.status_code}")
-            return None
+        st.info("Attempting to download video. This might take a moment...")
+        response = requests.get(url, stream=True, timeout=30)
+        response.raise_for_status() # Raise exception for bad status codes
+        
+        # Determine file extension (optional, but good practice)
+        content_type = response.headers.get('Content-Type', '')
+        suffix = '.mp4' if 'mp4' in content_type else '.mov'
+        
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+        total_size = int(response.headers.get('Content-Length', 0))
+        
+        downloaded_size = 0
+        progress_placeholder = st.empty()
+        
+        for chunk in response.iter_content(chunk_size=8192):
+            temp_file.write(chunk)
+            downloaded_size += len(chunk)
+            if total_size > 0:
+                progress = downloaded_size / total_size
+                progress_placeholder.progress(progress, text=f"Downloading: {downloaded_size/(1024*1024):.2f}MB / {total_size/(1024*1024):.2f}MB")
+        
+        temp_file.close()
+        progress_placeholder.empty()
+        return temp_file.name
+        
+    except requests.exceptions.RequestException as e:
+        st.error(f"Failed to download video: {str(e)}. Check URL and file access.")
+        return None
     except Exception as e:
-        st.error(f"Error downloading video: {str(e)}")
+        st.error(f"An unexpected error occurred during download: {str(e)}")
         return None
 
-# Main app layout
-tab1, tab2, tab3 = st.tabs(["📹 Video Input", "📊 Results", "ℹ️ About"])
+# --- Main App Layout ---
+tab1, tab2, tab3 = st.tabs(["📹 Video Input", "📊 Analysis & Results", "ℹ️ Documentation"])
 
 with tab1:
     col1, col2 = st.columns(2)
+    video_path = None
     
     with col1:
-        st.subheader("Upload Video")
+        st.subheader("📁 Upload Video File")
         uploaded_file = st.file_uploader(
             "Choose a video file", 
-            type=['mp4', 'avi', 'mov', 'mkv']
+            type=['mp4', 'avi', 'mov', 'mkv'],
+            help="Supported video formats. Maximum recommended file size: 50MB."
         )
         
         if uploaded_file is not None:
@@ -250,85 +336,92 @@ with tab1:
             tfile = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
             tfile.write(uploaded_file.read())
             video_path = tfile.name
-            
-            # Display video info
+            st.info(f"Video ready: {uploaded_file.name}")
             st.video(uploaded_file)
-            st.info(f"Uploaded: {uploaded_file.name}")
     
     with col2:
-        st.subheader("Video URL")
+        st.subheader("🌐 Load from Video URL")
         video_url = st.text_input(
-            "Enter video URL",
-            placeholder="https://example.com/video.mp4"
+            "Enter public video URL (e.g., direct link to .mp4)",
+            placeholder="https://example.com/traffic.mp4"
         )
         
-        if st.button("Load from URL") and video_url:
-            with st.spinner("Downloading video..."):
-                video_path = download_video_from_url(video_url)
-                if video_path:
-                    st.success("Video downloaded successfully!")
-                    # Display first frame
+        if st.button("🔗 Load from URL", use_container_width=True) and video_url:
+            video_path = download_video_from_url(video_url)
+            if video_path:
+                st.success("Video downloaded and ready for processing.")
+                # Try to display a frame if possible
+                try:
                     cap = cv2.VideoCapture(video_path)
                     ret, frame = cap.read()
                     if ret:
-                        st.image(frame, caption="First frame of video", use_column_width=True)
+                        st.image(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), caption="Video Preview", use_column_width=True)
                     cap.release()
+                except Exception:
+                    st.warning("Could not display video preview.")
+
+    st.markdown("---")
     
-    # Process button
-    if ('video_path' in locals() and video_path) or ('uploaded_file' in locals() and uploaded_file):
-        if st.button("🚀 Start Counting", type="primary"):
-            selected_classes = get_selected_classes()
+    # Process button logic
+    if video_path:
+        if st.button("🚀 START TRACKING AND COUNTING", type="primary", use_container_width=True):
+            selected_class_ids = get_selected_class_ids()
             
-            if not selected_classes:
-                st.warning("Please select at least one object type to count.")
+            if not selected_class_ids:
+                st.error("Please select at least one object type to count in the sidebar.")
             else:
-                with st.spinner("Processing video with YOLOv8..."):
-                    output_path = process_video(video_path, selected_classes)
-                    st.success("Processing complete!")
+                try:
+                    with st.spinner(f"Analyzing video with {model_name}..."):
+                        process_video(video_path, selected_class_ids, model_name)
+                    st.success("Analysis complete! See results in the 'Analysis & Results' tab.")
+                    # Automatically switch to results tab on completion? (Streamlit doesn't natively support this well)
+                except Exception as e:
+                    st.error(f"An error occurred during video processing: {e}")
+                    # Optionally print traceback
+                    # import traceback; st.code(traceback.format_exc())
+    else:
+        st.info("Upload a video or provide a URL to begin.")
 
 with tab2:
-    if st.session_state.processing_complete:
+    data = st.session_state.processed_data
+    if data['processing_complete']:
+        st.header("Results Summary")
+        
         col1, col2 = st.columns([2, 1])
         
         with col1:
-            st.subheader("Processed Video")
+            st.subheader("🎥 Analyzed Video Output")
             # Display processed video
-            video_file = open(st.session_state.processed_video, 'rb')
-            video_bytes = video_file.read()
+            with open(data['processed_video'], 'rb') as video_file:
+                video_bytes = video_file.read()
             st.video(video_bytes)
             
             # Download button
             st.download_button(
-                label="📥 Download Processed Video",
+                label="📥 Download Analyzed Video (MP4)",
                 data=video_bytes,
-                file_name="processed_video.mp4",
-                mime="video/mp4"
+                file_name="analyzed_tracking_video.mp4",
+                mime="video/mp4",
+                use_container_width=True
             )
-        
-        with col2:
-            st.subheader("📈 Total Counts")
             
+        with col2:
+            st.subheader("✅ Object Crossing Totals")
             # Display total counts
-            if st.session_state.total_counts:
-                for obj_type, count in st.session_state.total_counts.items():
-                    st.metric(label=obj_type.capitalize(), value=count)
+            if data['total_counts']:
+                for obj_type, count in data['total_counts'].items():
+                    st.metric(label=f"Total {obj_type.capitalize()} Crossed", value=count)
             else:
-                st.info("No objects detected")
-            
-            # Summary statistics
-            st.subheader("📊 Summary")
-            if st.session_state.frame_counts:
-                df = pd.DataFrame(st.session_state.frame_counts)
-                st.dataframe(df.tail(10), use_container_width=True)
-        
-        # Time series chart
-        st.subheader("📈 Objects Over Time")
-        if st.session_state.frame_counts:
-            df = pd.DataFrame(st.session_state.frame_counts)
+                st.info("No objects crossed the counting line in the analyzed section.")
+
+        st.subheader("📊 Object Presence Over Frames")
+        if data['frame_counts']:
+            df = pd.DataFrame(data['frame_counts']).fillna(0)
             
+            # Time series chart (Plotly)
             fig = go.Figure()
             
-            # Add a trace for each object type
+            # Add a trace for each object type (columns except 'frame')
             for column in df.columns:
                 if column != 'frame':
                     fig.add_trace(go.Scatter(
@@ -339,63 +432,67 @@ with tab2:
                     ))
             
             fig.update_layout(
-                title="Object Counts per Frame",
+                title="Count of Objects Present in Frame",
                 xaxis_title="Frame Number",
-                yaxis_title="Count",
+                yaxis_title="Count of Objects (Instance Count)",
                 hovermode='x unified',
                 height=400
             )
             
             st.plotly_chart(fig, use_container_width=True)
+            
+            st.subheader("Data Export")
+            st.dataframe(df.tail(10), use_container_width=True, height=200)
+            
+            csv = df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="⬇️ Download Frame-by-Frame Data (CSV)",
+                data=csv,
+                file_name="object_count_data.csv",
+                mime="text/csv",
+            )
+            
+        else:
+            st.warning("No tracking data available. Process a video first.")
+            
     else:
-        st.info("Process a video first to see results here.")
+        st.info("Process a video in the 'Video Input' tab to view analysis results.")
 
 with tab3:
+    st.header("Documentation: Smart Object Traffic Analyzer")
     st.markdown("""
-    ## About This App
+    This application utilizes cutting-edge computer vision techniques for object tracking and crossing counting.
     
-    ### 🔧 Technology Stack
-    - **YOLOv8**: State-of-the-art object detection model
-    - **Streamlit**: Interactive web app framework
-    - **OpenCV**: Computer vision library for video processing
-    - **Plotly**: Interactive visualizations
+    ### 🔑 Core Technology
     
-    ### 📋 Features
-    1. **Multiple Input Sources**: Upload videos or use URLs
-    2. **Customizable Detection**: Select specific object classes
-    3. **Real-time Counting**: Track objects frame by frame
-    4. **Visual Analytics**: Interactive charts and statistics
-    5. **Export Results**: Download processed videos and data
+    * **YOLOv8**: The primary model for high-accuracy, real-time object detection. We recommend the `yolov8n.pt` (Nano) for speed in browser-based demos.
+    * **ByteTrack**: Used via the `ultralytics` package for robust object tracking, assigning a unique ID to each detected instance across frames.
+    * **Streamlit**: Provides the interactive, professional front-end interface.
     
-    ### 🎯 Use Cases
-    - **Traffic Monitoring**: Count vehicles on roads
-    - **Retail Analytics**: Track customer movements
-    - **Crowd Management**: Monitor people density
-    - **Security**: Detect and count objects of interest
+    ---
     
-    ### ⚠️ Limitations
-    - Processing speed depends on video length and resolution
-    - Maximum 200 frames processed in this demo
-    - Accuracy depends on model confidence settings
+    ### ⚙️ How Crossing Counting Works
     
-    ### 📚 How to Use
-    1. Upload a video or provide a URL
-    2. Configure detection settings in the sidebar
-    3. Click "Start Counting"
-    4. View results in the Results tab
-    5. Download processed video and data
+    Unlike simple detection counters which add to a total for every frame an object is visible, this app counts **unique object crossings** of a vertical line:
     
-    ---
+    1.  **Tracking**: YOLOv8's integrated tracker assigns a persistent **Track ID** to each object (`person`, `car`, etc.).
+    2.  **Centroid Calculation**: The center-point (centroid) of the object's bounding box is calculated for every frame.
+    3.  **Crossing Logic**: The system monitors the object's horizontal position relative to the **Counting Line**. An object is counted **once** when its centroid moves from one side of the line (e.g., left) to the other (e.g., right).
     
-    **Note**: This app runs on Hugging Face Spaces with limited resources. 
-    For heavy processing, consider running locally with GPU support.
-    """)
-
-# Footer
-st.markdown("---")
-st.markdown(
-    "<div style='text-align: center'>"
-    "Built with ❤️ using YOLOv8, Streamlit, and Hugging Face Spaces"
-    "</div>",
-    unsafe_allow_html=True
-)
+    This ensures an accurate count of unique events, not redundant detections.
+    
+    ### 🚀 Deployment on Hugging Face Spaces
+    
+    This script is optimized for deployment:
+    
+    * **Caching (`@st.cache_resource`)**: The YOLO model is loaded only once, saving significant time.
+    * **Dependency List**: You will need a `requirements.txt` file in your Space with the following key libraries:
+        ```text
+        streamlit
+        ultralytics
+        opencv-python-headless
+        numpy
+        plotly
+        pandas
+        requests
+        scipy # for distance calculation, though not strictly needed with bytetrack