🤖Real-Time Object Detection using Python🚀

🏢About

Hello! I'm Usha Pithani, and I led this real-time object detection project.

🔍How it Works

1. ⚙️ Set up your Python environment with required libraries (OpenCV, PyTorch, etc.).
2. 🤩 Load a pre-trained object detection model (e.g., YOLOv11).
3. 🎥 Process camera or video feeds to identify and classify objects.
4. 📦 Display results with bounding boxes and labels in real time.

💡Understanding Real-Time Object Detection

Real-time object detection involves identifying and localizing objects within video streams as they happen, with minimal latency. This technology is at the heart of many modern applications, including:

• Autonomous vehicles (identifying pedestrians, other cars, traffic signs)
• Security and surveillance (detecting suspicious activities)
• Robotics (enabling robots to interact with their environment)
• Augmented reality (overlaying digital information onto real-world objects)

Key Components:

• Deep Learning Models: Architectures like YOLO (You Only Look Once), SSD (Single Shot MultiBox Detector), and Faster R-CNN are designed for speed and accuracy. YOLO is particularly popular for real-time applications due to its single-pass detection approach.
• Computer Vision Libraries: Libraries such as OpenCV are essential for handling video streams, image preprocessing, and drawing annotations (bounding boxes, labels) on the frames.
• Hardware Acceleration: For optimal real-time performance, especially with higher resolutions or more complex models, a powerful GPU (Graphics Processing Unit) is often utilized to accelerate computations.

This project specifically leverages **YOLOv11** for its balance of speed and accuracy, and **OpenCV** for camera interaction and display.

💻Running the Project in VS Code

Follow these steps to set up and run the real-time object detection project using your laptop's webcam in Visual Studio Code.

1. Prerequisites:

• Python 3.8+ installed on your system.
• Visual Studio Code installed.
• An **active internet connection** for initial model download.

2. Environment Setup:

It's crucial to use a virtual environment to manage project dependencies. Open VS Code, navigate to your desired project folder, and open a new terminal (Ctrl+Shift+`).

Create and activate a virtual environment:

# Create virtual environment
python -m venv venv

# Activate on Windows (PowerShell)
.\venv\Scripts\Activate.ps1

# Activate on Windows (Command Prompt)
venv\Scripts\activate.bat

# Activate on macOS/Linux
source venv/bin/activate

Once activated (you'll see (venv) in your terminal prompt), install the required libraries:

# Install PyTorch (CPU version - suitable for most laptops)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

# Install OpenCV and other utilities
pip install opencv-python numpy matplotlib seaborn

# Install Ultralytics (includes YOLOv11 support)
pip install ultralytics

Note: If you have an NVIDIA GPU, visit PyTorch's website for the CUDA-enabled installation command for faster inference.

3. Create the Python Script:

3.1 In VS Code, create a new file named yolo_realtime_webcam.py and paste the following code for Real-Time Object Detection Using Webcam📷:

import cv2
from ultralytics import YOLO

# Print OpenCV version
print(f"OpenCV version: {cv2.__version__}")

# Load the latest YOLO11 model (choose model size: n, s, m, l, x)
model = YOLO("yolo11s.pt")  # Alternatives: 'yolo11n.pt', 'yolo11m.pt', etc.

# Open the laptop webcam
cap = cv2.VideoCapture(0)
if not cap.isOpened():
    print("Error: Could not access the webcam.")
    exit()

print("Webcam opened successfully. Press 'q' to quit the detection window.")

try:
    while True:
        ret, frame = cap.read()
        if not ret:
            print("Failed to grab frame.")
            break

        # Run detection; YOLO expects BGR frames (default for OpenCV)
        results = model.predict(source=frame, show=False, stream=False)

        # Overlay boxes; results[0].plot() returns BGR image
        annotated_frame = results[0].plot()

        # Display result
        cv2.imshow("YOLO11 Real-time Detection", annotated_frame)

        # Exit on 'q'
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
finally:
    cap.release()
    cv2.destroyAllWindows()
    print("Webcam released and windows closed.")

```

import cv2
from ultralytics import YOLO

def traffic_analysis_yolo_bytetrack(video_path, output_path="output_traffic.mp4"):
    model = YOLO("yolo11n.pt")

    # Open the video file
    cap = cv2.VideoCapture(video_path)
    if not cap.isOpened():
        print(f"Error: Could not open video file {video_path}")
        return

    # Get video properties
    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps = int(cap.get(cv2.CAP_PROP_FPS))

    # Define the codec and create VideoWriter object
    fourcc = cv2.VideoWriter_fourcc(*'mp4v') # You can use 'XVID' or 'MJPG'
    out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))

    print("Starting vehicle detection and tracking...")

    while True:
        ret, frame = cap.read()
        if not ret:
            print("End of video or error reading frame.")
            break
            
        results = model.track(frame, persist=True, tracker="bytetrack.yaml", conf=0.3, iou=0.5, show=False)

        # Process results
        if results and results[0].boxes.id is not None:
            # Get annotated frame with bounding boxes and track IDs
            annotated_frame = results[0].plot()

            # Display the frame
            cv2.imshow("Traffic Analysis", annotated_frame)
            
            out.write(annotated_frame)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    # Release resources
    cap.release()
    out.release()
    cv2.destroyAllWindows()
    print(f"Traffic analysis completed. Output saved to {output_path}")

if __name__ == "__main__":
    # Replace with your video file path
    input_video = "road_traffic.mp4" 
    
    traffic_analysis_yolo_bytetrack(input_video)
  ```

python yolo_realtime_webcam.py

python traffic_analyzer.py