🤖Real-Time Object Detection using Python🚀

🏢About Eduexpose & My AI/ML Internship

Hello! I'm **Madhusai**, and I led this real-time object detection project. This initiative was developed as part of my Project-Based Internship in Artificial Intelligence with Eduexpose. My passion for AI, Cloud, and Software Development drove this project, which focused on the practical application of AI and Machine Learning to build robust real-world systems. You can learn more about my professional journey on my LinkedIn profile.

My internship at Eduexpose ran from **June 1, 2025, to July 31, 2025**. It involved a structured work schedule and tasks designed to enhance skills in AI, reflecting the core role within the Artificial Intelligence project. The experience provided valuable insights into project development, execution, and adherence to professional standards, including maintaining confidentiality of proprietary information.

🔍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