somewhat working commit of people counter

.gitignore

@@ -0,0 +1,14 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Videos and Models ckpts
+*.pt
+*.mp4

.python-version

@@ -0,0 +1 @@
+3.12

README.md

@@ -0,0 +1,48 @@
+# CCTV People Counter
+
+This program counts the number of people entering through a specified line in a video feed (e.g., store entrance). It uses YOLOv8 for person detection and tracking.
+
+## Features
+
+- Real-time person detection using YOLOv8
+- Object tracking to count unique entries
+- Customizable counting line position
+- Optional video output saving
+- Visual display of count and tracking
+
+## Setup
+
+1. Ensure you have Python 3.12+ installed
+2. Install dependencies:
+   ```bash
+   pip install .
+   ```
+
+## Usage
+
+Basic usage:
+```bash
+python main.py video_path
+```
+
+With optional parameters:
+```bash
+python main.py video_path --line-position 0.6 --output custom_output.mp4
+```
+
+### Parameters
+
+- `video_path`: Path to input video file (required)
+- `--line-position`: Position of counting line (0-1, as fraction of frame height, default: 0.5)
+- `--output`: Path to save output video (default: result.mp4)
+
+### Controls
+
+- Press 'q' to quit the program
+
+## How it Works
+
+1. Uses YOLOv8 to detect people in each frame
+2. Tracks detected people across frames
+3. Counts when a tracked person crosses the specified line from top to bottom
+4. Displays real-time count and visualizations

main.py

@@ -0,0 +1,141 @@
+import cv2
+import numpy as np
+from ultralytics import YOLO
+from collections import defaultdict
+import argparse
+
+class PersonCounter:
+    def __init__(self, line_position=0.5):
+        """Initialize person counter.
+        
+        Args:
+            line_position (float): Virtual line position as fraction of frame height (0-1)
+        """
+        self.model = YOLO("yolov8n.pt")  # Load pretrained YOLOv8 model
+        self.tracker = defaultdict(list)  # Track object IDs
+        self.crossed_ids = set()  # Store IDs that have crossed the line
+        self.line_position = line_position
+        self.count = 0
+
+    def _calculate_center(self, box):
+        """Calculate center point of detection box."""
+        x1, y1, x2, y2 = box
+        return (x1 + x2) / 2, (y1 + y2) / 2
+
+    def process_frame(self, frame):
+        """Process a single frame and update count.
+        
+        Args:
+            frame: Input frame from video
+        Returns:
+            frame: Annotated frame
+            count: Current count of people who entered
+        """
+        height, width = frame.shape[:2]
+        line_y = int(height * self.line_position)
+
+        # Draw counting line
+        cv2.line(frame, (0, line_y), (width, line_y), (0, 255, 0), 2)
+
+        # Run detection and tracking
+        results = self.model.track(frame, persist=True, classes=[0])  # class 0 is person
+        
+        if results[0].boxes.id is not None:
+            boxes = results[0].boxes.xyxy.cpu().numpy()
+            track_ids = results[0].boxes.id.cpu().numpy().astype(int)
+
+            # Process each detection
+            for box, track_id in zip(boxes, track_ids):
+                # Draw bounding box
+                cv2.rectangle(frame, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])), 
+                            (255, 0, 0), 2)
+
+                # Get center point of the bottom edge of the box (feet position)
+                center_x = (box[0] + box[2]) / 2
+                feet_y = box[3]  # Bottom of the bounding box
+                
+                # Draw tracking point
+                cv2.circle(frame, (int(center_x), int(feet_y)), 5, (0, 255, 255), -1)
+                
+                # Store tracking history
+                if track_id in self.tracker:
+                    prev_y = self.tracker[track_id][-1]
+                    # Check if person has crossed the line (moving down)
+                    if prev_y < line_y and feet_y >= line_y and track_id not in self.crossed_ids:
+                        self.crossed_ids.add(track_id)
+                        self.count += 1
+                        # Draw crossing indicator
+                        cv2.circle(frame, (int(center_x), int(line_y)), 8, (0, 0, 255), -1)
+                
+                # Update tracking history
+                self.tracker[track_id] = [feet_y]  # Only store current position
+
+        # Draw count with bigger font and background
+        count_text = f"Count: {self.count}"
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 1.5
+        thickness = 3
+        (text_width, text_height), _ = cv2.getTextSize(count_text, font, font_scale, thickness)
+        
+        # Draw background rectangle
+        cv2.rectangle(frame, (10, 10), (20 + text_width, 20 + text_height),
+                     (0, 0, 0), -1)
+        # Draw text
+        cv2.putText(frame, count_text, (15, 15 + text_height), 
+                    font, font_scale, (0, 255, 0), thickness)
+        
+        return frame, self.count
+
+def main():
+    parser = argparse.ArgumentParser(description='Count people entering through a line in video.')
+    parser.add_argument('video_path', help='Path to input video file')
+    parser.add_argument('--line-position', type=float, default=0.5,
+                       help='Position of counting line (0-1, fraction of frame height)')
+    parser.add_argument('--output', default='result.mp4', help='Path to output video file (default: result.mp4)')
+    args = parser.parse_args()
+
+    # Initialize video capture
+    cap = cv2.VideoCapture(args.video_path)
+    if not cap.isOpened():
+        print(f"Error: Could not open video at {args.video_path}")
+        return
+
+    # Get video properties
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+
+    # Initialize video writer
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    writer = cv2.VideoWriter(args.output, fourcc, fps, (width, height))
+
+    # Initialize person counter
+    counter = PersonCounter(line_position=args.line_position)
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # Process frame
+        processed_frame, count = counter.process_frame(frame)
+
+        # Display frame
+        cv2.imshow('Frame', processed_frame)
+
+        # Write processed frame to output video
+        writer.write(processed_frame)
+
+        # Break on 'q' press
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    print(f"Final count: {counter.count}")
+
+    # Clean up
+    cap.release()
+    writer.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "cctv-ppl-count"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "opencv-python",
+    "numpy",
+    "ultralytics",
+    "pip>=25.0.1",
+]