REAL TIME OBJECT DETECTION

PROJECT SYNOPSIS
OF MAJOR PROJECT

BACHELOR OF TECHNOLOGY

DATA SCIENCE & VIIIth SEM

SUBMITTED BY
​ ​ ​ Ayushi Singh – 2101331540028
​ ​ ​

NOIDA INSTITUTE OF ENGINEERING & TECHNOLOGY,

GREATER NOIDA, UTTAR PRADESH
 STUDENT’S DECLARATION

I hereby certify that the work which is being presented in the major project
report entitled " REAL TIME OBJECT DETECTION " in fulfilment of the
requirement for the award of the Degree of Bachelor of Technology in
Department of CSE(DATA SCIENCE) of Noida Institute Of Engineering and
Technology, Greater Noida, U.P. is an authentic record of my own work carried
out during VIIIth semester.

Date: ​ ​ ​ ​ ​ ​ Name and Signature of student

The major project viva-voice examination of Mr./Ms. ________________, Roll

No. ________________ of B.TECH (DATA SCIENCE) has been held on
_______.

Signature of:

Project Guide: __________​ ​ ​ ​ Head of Department:

​ ​ ​ ​ ​ ​ ​ ​ (Stamp of organization)

External Examiner: _________​​ ​ Internal Examiner: ________

 ACKNOWLEDGEMENT
We are highly grateful to the Dr. ______________, HOD, Noida Institute Of
Engineering and Technology, Greater Noida, U.P, for providing this opportunity.
The constant guidance and encouragement received from
_______________,HOD (Data Science), NIET, UP has been of great help in
carrying out the project work and is acknowledged with reverential thanks.
We would like to express a deep sense of gratitude and thanks profusely to
_________ project guide, without the wise counsel and able guidance, it would
have been impossible to complete the report in this manner.
We express gratitude to other faculty members of _______________ department
of NIET for their intellectual support throughout the course of this work.
Finally, the authors are indebted to all whosoever have contributed in this report
work.

​ ​ ​ ​ ​ ​ ​ AYUSHI SINGH
NAME OF THE STUDENT
 FIGURE INDEX

Figure No. Description Page No.

2.1 Use Case
3.1 Flowchart
3.2 ER Diagram
3.4 Software Development Model
3.6 DFD Level 0
3.6.2 DFD Level 1
3.6.3 DFD Level 2
3.7 Class Diagram
3.8 Activity Diagram
3.9 Sequence Diagram
 TABLE INDEX

Table No. Description Page No.

1.4 Definition, Acronyms and Abbreviations

2.2.3 User classes and characteristics

2.2.5.1 Viewers Table
2.2.5.2 Admin Table
2.2.6.1 Hardware Constraints
2.2.6.2 Software Constraints
2.2.7 Use case model
2.4.1 User interface
2.4.2 Hardware interface
2.4.3 Software interface
2.4.4 Communication interface
3.3 Design Methodology
3.5 Database design
 CONTENTS
Chapter 1- Introduction
1.1​Objective
1.2​Problem definition
1.3​Scope
1.4​Definitions, Acronyms and Abbreviations
1.5​Technologies to be used
Chapter 2- Software Requirement Specifications
2.1 Introduction
​ 2.1.1 Purpose
​ 2.1.2 Project Scope
2.2 Overall Description
​ 2.2.1 Product/Project Perspective
​ 2.2.2 Product/Project Function
​ 2.2.3 User Classes and Characteristics
​ 2.2.4 Operating Environment
​ 2.2.5 Architecture Design
​ 2.2.6 Constraints
​ 2.2.7 Use Case Model Description​
​ 2.2.8 Assumptions and Dependencies
2.3 System Features
2.4 External Interface Requirements
​ 2.4.1 User Interfaces
​ 2.4.2 Hardware Interfaces
​ 2.4.3 Software Interfaces
​ 2.4.4 Communication Interfaces
2.5 Other Nonfunctional Requirements
​ 2.5.1 Performance Requirements
​ 2.5.2 Safety Requirements
​ 2.5.3 Security Requirements
​ 2.5.4 Software Quality Attributes
Chapter 3- System Design
3.1 Flowcharts
3.2 ER Diagram
3.3 Design Methodology
3.4 Software Development Model
3.5 Database Design
3.5.1 ER Diagram
3.5.2 Schema
3.6 DFD’s
3.7 Activity Diagram
3.8 Class Diagram
3.9.Sequence Diagram
Chapter 4- System Implementation
4.1 Coding
4.2 Testing
4.3 Snapshots
Chapter 5- Conclusions and future scope
5.1 Conclusion
5.2 Future Scope
Chapter 6- References
6.1 Books & URLs
 Chapter 1- Introduction
1.1 Objectives:
The objective of this project is to implement a real-time object detection system using the
YOLO (You Only Look Once) and Open cv algorithm to accurately detect and localize
multiple objects in video streams. The goal is to achieve fast and efficient performance
suitable for real-world applications like surveillance, autonomous navigation, and smart
systems.

1.2 Problem Definition:

Traditional object detection methods struggle to balance speed and accuracy for real-time
applications. This project addresses the need for a fast and reliable solution by leveraging the
YOLO algorithm for real-time object detection in dynamic environments.

1.3 Scope:
This project has significant potential in fields like:

●​ Autonomous vehicles – Critical for detecting pedestrians, vehicles, and obstacles to

ensure safe and efficient navigation.

●​ Surveillance systems – Essential for real-time threat detection, intrusion alerts, and
enhanced public safety.

●​ Industrial automation – Key in identifying defects, ensuring quality control, and

improving operational efficiency.

●​ Smart cities – Valuable for traffic management, violation detection, and urban
planning enhancements.

1.4 Definitions, Acronyms and Abbreviations:

Acronym Definition
AI Machine-based intelligence that enables object recognition
YOLO YOU ONLY LOOK ONCE
coco names A pre-trained model for object detection
OpenCV Open-source computer vision library.
Numpy Handles images and speeds up data processing in object detection

1.5 Technologies Used:

●​ Frontend: TensorFlow.js or OpenCV.js
●​ Database: SQL
●​ Machine Learning: OpenCV, CNN,YOLO3,SSD (Single Shot MultiBox Detector)
●​ Hardware: Camera (webcams) for capturing images.
Chapter 2 - Software Requirement Specifications

2.1 Introduction:
2.1.1 Purpose:
The primary objective of this project is to design and implement a real-time object detection
system capable of identifying, localizing, and tracking multiple objects from live video feeds
or camera inputs. This technology aims to enhance automation, safety, and operational
efficiency in various domains. The system uses advanced machine learning and computer
vision techniques to process visual data instantly and provide meaningful insights.

●​ Automated Detection: Detect and classify objects (e.g., people, vehicles) in real time
without human input.

●​ Better Decision-Making: Provide real-time data for faster, smarter decisions in areas
like traffic and retail.

●​ Flexible & Scalable: Adapt to different environments and support multiple camera
inputs.

●​ Improved Safety: Monitor industrial areas to prevent accidents and automate checks.

●​ Smart Applications: Power systems like self-driving cars, smart homes, and
automated retail.

2.1.2 Project Scope:

This project aims to develop a real-time object detection system that identifies and classifies
objects from live video feeds using deep learning models like YOLO. It includes real-time
processing, edge device deployment, database integration, alert generation, and basic result
visualization, while excluding advanced features like facial recognition or multi-camera
tracking.
Key Functionalities:

●​ Live Object Detection: Detect and classify objects (e.g., people, vehicles) in real
time from video feeds.
●​ Real-Time Alerts: Trigger alerts or notifications when specific objects or events are
detected.
●​ Edge Device Processing: Run detection models efficiently on edge devices (e.g.,
Jetson Nano, Raspberry Pi).
 ●​ Database Logging: Store detection results with timestamps and metadata in a
structured database.
●​ Visualization Dashboard: Display live video with detection overlays and object info
on a user interface.
.

2.2 Overall Description:

2.2.1 Product/Project Perspective:
The system is a desktop-based application with a GUI developed using YOLO. It interacts
with:

●​ A webcam for real-time face detection.

●​ A SQL database for storing data.
●​ Machine Learning algorithms (OpenCV,CNN,YOLO,SSD) for accurate face
recognition.
This project focuses on developing an advanced, real-time object detection system using the
YOLO (You Only Look Once) model, known for its speed and accuracy in processing video
feeds. The goal is to provide an efficient, scalable solution for detecting and classifying
multiple objects (e.g., people, vehicles, animals) in live environments such as security
surveillance, traffic monitoring, and industrial automation.
Key Components of the System:

●​ YOLO Model:The core deep learning model used to detect and classify objects in
real-time from video streams.
●​ Edge Computing Device:Hardware (e.g., NVIDIA Jetson Nano) used for local
processing of detection tasks, ensuring low-latency performance.
●​ Video Capture System:Cameras (IP cams, surveillance cameras) that provide
real-time video feeds for object detection.
●​ Database for Data Logging: Stores detection results, including object type,
confidence scores, and timestamps for later analysis.
●​ User Interface (UI) & Visualization:A dashboard that displays live video feeds,
detected objects with their locations, and real-time alerts

2.2.2 Product/Project Function:

The system provides several key functionalities for people to detect obkect:

1.​ Registration Module:

o​ User Registration: Allows users to create an account with essential details.
o​ Device Registration: Adds edge devices (e.g., cameras) for detection tasks.
o​ User Authentication: Validates user credentials for secure access.
.
2. Face Recognition Module
○​ Face Identification:Matches detected faces with stored data using models like
FaceNet or OpenCV.
○​ Real-Time Matching:Instantly compares faces against the database for
immediate recognition.
○​ Alert System: Sends alerts when specific individuals are recognized (e.g.,
VIPs or intruders).
○​ Data Logging & Database Integration:Saves recognition data (e.g., names,
timestamps) and manages facial profiles.​

●​ Report Generation Module:

o​ Generates daily, weekly, or custom reports based on object and face detection
events (e.g., counts, timestamps, object types).
o​ Allows filtering by date, device, object type, or user, and summarizes key
metrics for quick analysis.
o​ Supports exporting reports in formats like PDF or CSV and enables easy
sharing via email or dashboard access.

2.2.3​ User Classes and Characteristics:

User Class Description Permissions
Admin Manages users, devices, system settings, Full access to all system
and reports. features.
Viewer/User Views live feeds, reports, and detection Read-only access.
history
Operator Monitors Detections & Manage alert Limited admin access

Developer Handles backend, model updates & Full system and backend
system integration access.

2.2.4 Operating Environment:

The system operates on Windows and requires the following hardware and software
components:

●​ Hardware Requirements:
o​ Computer/Laptop – Windows based system.
o​ Camera – Captures real-time video (e.g., USB, IP, or CSI cameras).
o​ Edge Device – Runs YOLO locally (e.g., Jetson Nano, Raspberry Pi).
 o​ GPU/CPU – High-performance processing (e.g., NVIDIA RTX GPU or
desktop CPU).
o​ Storage – Saves detection data and logs (SSD/HDD).

●​ Software Requirements:
o​ Python 3.x – The programming language used.
o​ Deep Learning Framework – TensorFlow or PyTorch for YOLO model.

o​ YOLO Model – YOLOv3 or YOLOv4 for real-time detection.

o​ CUDA/cuDNN – For GPU acceleration (NVIDIA devices).

o​ OpenCV – For video processing and object tracking.

o​ Database – MySQL or MongoDB for storing data.

2.2.5 Architecture Design:

The architecture for real-time object detection using YOLO consists of a video input pipeline
that captures and preprocesses frames, followed by YOLO-based inference for detecting
objects, and postprocessing to display or act on the results. It supports modular deployment
on edge or cloud platforms, enabling fast, efficient, and scalable object recognition
1.​ Presentation Layer (User Interface) [Frontend]:
o​ The presentation layer displays the real-time detection results by overlaying
bounding boxes and labels on video frames using OpenCV or a web-based
dashboard. It provides an intuitive interface for users to visualize, interact with, or
monitor detected objects seamlessly.
o​ Key Features of the Presentation Layer:
✔​ Real-Time Visualization – Displays video frames with bounding
boxes, class labels, and confidence scores.
✔​ User Interface (UI) – Interactive UI for viewing live detections via
desktop (OpenCV window) or browser (Flask/Django dashboard)
✔​ Alert System Integration – Visual or audible alerts when specific
objects are detected.
✔​ Frame Rate Display – Shows FPS (Frames Per Second) to monitor
performance
✔​ Recording & Snapshot Options – Allows saving video clips or
screenshots of detected frames.
 ✔​ Multi-Device Compatibility – Responsive design for viewing on
PC, tablet, or mobile.
✔​ Object Tracking Visualization – (If enabled) Shows object IDs and
tracking paths over time.
✔​ Customization Panel – Toggle object classes, confidence thresholds,
or switch between camera feeds.

o​ Technologies Used in the Presentation Layer:

✔​ OpenCV – Core library for visualizing detections by drawing
bounding boxes and displaying video frames.
✔​ Flask – Lightweight backend framework to serve real-time results via
a web dashboard.
✔​ HTML / CSS / JavaScript – Essential for building and styling the
user interface.
✔​ WebSockets (Socket.IO) – Enables real-time streaming of detection
data to the frontend.
.

2.​ Business Logic Layer (Processing & Machine Learning) [Backend]:

o​ The Business Logic Layer handles the core processing by running YOLO
inference on preprocessed video frames to detect and classify objects in real-time.
It also applies postprocessing techniques like Non-Max Suppression and filters
results based on confidence thresholds before sending them to the presentation
layer..
o​ Key features of the Business Logic Layer:
✔​ Real-Time YOLO Inference:Core functionality that enables fast
object detection and classification on each video frame.
✔​ Postprocessing with Non-Maximum Suppression (NMS):Eliminates
redundant bounding boxes to improve detection accuracy.
✔​ Confidence Threshold Filtering:Ensures only high-confidence
detections are forwarded, reducing false positives.
✔​ Low-Latency Performance:Optimized for real-time processing to
maintain responsiveness and smooth user experience.
 o​ Technologies Used in the Business Logic Layer:
✔​ YOLO (e.g., YOLOv5 or YOLOv8):Core deep learning model used
for fast and accurate object detection.
✔​ PyTorch:The primary deep learning framework for implementing and
running the YOLO model.
✔​ OpenCV: Handles real-time video stream input, frame extraction, and
basic image processing tasks.
✔​ Python:Main programming language tying together model inference,
post processing, and data flow logic.
✔​ CUDA (GPU Acceleration):Boosts performance by running inference
on NVIDIA GPUs, essential for real-time speed.

o​ Workflow of the Face Recognition Process:

✔​ Capture Frame – Get video frames from a camera or video source
(e.g., using OpenCV).
✔​ 2. Preprocess Frame – Resize, normalize, and prepare the frame for
the YOLO model.
✔​ 3. YOLO Inference – Run the frame through the YOLO model to
detect objects.
✔​ 4. Apply NMS – Use Non-Maximum Suppression to remove
duplicate/overlapping boxes.
✔​ 5. Filter by Confidence – Keep only detections above a set confidence
threshold.
✔​ 6. Format Output – Structure detected results (label, score, box
coordinates).
✔​ 7. Display/Send Results – Show on screen or send to another system
or UI.
✔​ 8. Repeat – Continue with the next frame for real-time performance.

3.​ Data Storage Layer (Database & File Management) [Backend]

o​ The Data Storage Layer handles saving detection results, metadata, and logs into
structured databases for later analysis. It also manages file storage for captured
frames, annotated images, or video clips as needed for auditing or training.
o​ Key Features of the Data Storage Layer:
✔​ Detection Result Logging: Stores object detection data (class,
confidence, timestamp, coordinates) for analysis.
✔​ Structured Data Storage: Uses databases (e.g., SQLite, PostgreSQL)
to efficiently organize and retrieve metadata.
✔​ Scalability: Capable of handling large data volumes for long-term or
continuous monitoring.
✔​ Data Retrieval & Query Support: Enables quick querying of
detection data for reports, analysis, or retraining.
✔​ Backup & Recovery: Ensures data reliability by supporting backup
mechanisms to prevent data loss.
✔​ Database Schema (MySQL Table):
The Viewer and Admin tables in a real-time object detection project.
The schema includes essential fields and relationships that might be
involved:
▪​ Viewer Table – Holds the details of viewers who access the system
to view detections or monitoring outputs.

Field Name Data Type Description

viewer_id INT(Primary key) Unique identifier for each viewer

first_name VARCHAR(100) First name of the viewer

last_name VARCHAR(100) Last name of the viewer

email VARCHAR(255) Email address for communication.

password_hash VARCHAR(255) Hashed password for authentication

last_login DATETIME Timestamp of the last login

created_at DATETIME Timestamp when the viewer

account was created.

updated_at DATETIME Timestamp when the viewer

account was last updated.

status ENUM Account status (active or inactive)

▪​ Admin – . Holds admin details, with roles like super_admin or

moderator, allowing for control over user access and system
settings.

Column Name Data Type Description

admin_id INT Unique identifier of the admin

 first_name VARCHAR (100) First Name of the admin

last_nme VARCHAR 100) Last Name of

password_hash VRCHAR (255) Hashed password for admin

authentication

email VARCHAR(255) Admin's email address.

role ENUM(super_admi Role of admin

n)

last_login DATETIME Last Login

created_at DATETIME Account created

updated_at DATETIME Last updated

status ENUM(active,inact Account status (active or

ive) inactive).

2.2.6 Constraints:
The project must ensure real-time processing with minimal latency (under 100ms/frame) and
maintain high detection accuracy (80-90%) while handling scalable data storage and secure
user authentication. It should also meet performance, security, and availability requirements,
including efficient resource usage, data retention, and backup mechanisms
These constraints can be categorized into:
I.​ Hardware Constraints:
o​ GPU/CPU Usage: Must support GPU acceleration for real-time
detection, with CPU fallback for edge devices.
o​ Fast Storage: Requires high-performance storage (e.g., SSD) for quick
data handling.
o​ Power Efficiency: Needs optimization for low power consumption,
especially in battery-powered deployments.
o​ System Requirements:

Component Minimum Requirement Recommended

Processor Intel i3 (or equiv) Intel i5/i7 or AMD
Ryzen 5/7
RAM 4GB 8GB or higher
Storage 500MB (for db) 1GB+ (for
multiple users)
Camera 720p webcam 1080p HD Camera
 II.​ Software Constraints:
o​ The system is designed to run on Windows.
o​ Real-Time Processing: Ensure low-latency (under 100ms/frame) for
real-time detection.
o​ Cross-Platform Compatibility: Support multiple platforms (cloud,
edge, local servers) efficiently.
o​ Dependencies:

Library Purpose Constraint

OpenCV Video capture, frame Efficient handling of
processing, and display video streams with
minimal resource usage.
YOLO Real-time object detection Must deliver high
and classification accuracy with low
latency (under
100ms/frame)
PyTorch/Tensor Framework for running Needs GPU acceleration
Flow deep learning models for fast inference and
scalable on CPUs.
SQL Database Storage for metadata and Efficient querying for
logs large datasets with
minimal delay.

III.​ Performance Constraints:

o​ Low Latency: Detection under 100ms per frame.
o​ High FPS: Support 30–60 frames per second.
o​ High Accuracy: Maintain 80–90% detection accuracy.
o​ Resource Efficient: Optimize CPU, GPU, and memory usage.

IV.​ Security Constraints:

o​ Authentication: Restrict access to authorized users with secure
password handling.
o​ Data Privacy: Protect video data and logs from unauthorized access..

2.2.7 Use Case Model Description:

The Face Recognition Smart Attendance System follows a structured use case model to
describe how different users interact with the system. These are:
1.​ Use Case Model – A use case model represents the system’s functionalities through
actors (users) and use cases (interactions with the system). It helps in identifying
system functionalities, defining user roles and permissions, and undertaking system
workflows.

Actor Description
 Admin Manages users, devices, system settings, and reports.

Viewers Views live feeds, reports, and detection history

2.​ Use Case Diagram:

​ ​ ​ ​ Fig: 2.1
2.2.8 Assumptions and Dependencies The Real Time Object Detection System relies
on several assumptions and dependencies that must be met for the system to function
correctly.

❖​ Assumptions:
●​ Hardware Assumptions –
o​ Dedicated GPU (e.g., NVIDIA RTX) for real-time inference.
o​ High-resolution camera (1080p or above) for input.
o​ Minimum 8GB–16GB RAM for smooth processing.
o​ SSD storage for model files and runtime data.

●​ Software Assumptions –
o​ The system will be installed on Windows.
o​ Python (3.x) is installed and properly configured.
o​ Required libraries like PyTorch, OpenCV, and YOLO are available.
o​ OS supports GPU drivers (e.g., CUDA for NVIDIA GPUs).
o​ Internet access is available for initial model downloads and
updates.
 ●​ User Assumptions –
o​ Users have basic knowledge of running Python scripts and handling
command-line tools.
o​ Users can install necessary dependencies and configure the
environment.
o​ Users understand how to operate the camera and interpret detection
results.
●​ Security & Privacy Assumptions –
o​ User data and images stored in the database will be kept secure.
o​ The system assumes video data is processed locally to maintain user
privacy.
o​ It is assumed that access to the system is restricted to authorized
users only.

❖​ Dependencies:
●​ Hardware Dependencies –
o​ CUDA-compatible GPU for fast inference
o​ Camera (USB/IP/CSI) for live video input
o​ Multi-core CPU for general processing
o​ 8GB–16GB RAM for smooth performance
o​ SSD for fast data access
o​ Stable power supply for continuous operation
●​ Software Dependencies –
o​ Python (3.x) – programming language for development.
o​ PyTorch – framework for running YOLO models.
o​ OpenCV – for video capture and image processing.
o​ YOLO (v5/v8) – object detection model.
o​ CUDA & cuDNN – GPU acceleration (for NVIDIA hardware).

●​ Database Dependencies –
o​ MySQL Database

2.3 System Features:

The system provides real-time object detection with high accuracy using YOLO, processing
live video feeds. It supports various object classes and outputs detection results with
bounding boxes and labels on the video stream.
Functional Features:The system detects and classifies objects in real-time, displaying labels
and bounding boxes on live video streams..
a.​ Real-time Object Detection:–
✔​ Processes live video streams frame by frame for immediate detection.
✔​ Identifies and classifies objects with high accuracy using YOLO.
✔​ Operates with minimal latency, making it suitable for applications like
surveillance and autonomous systems.

b.​ Bounding Box Visualization–

✔​ Draws bounding boxes around detected objects, indicating their
position.
✔​ Boxes are updated in real-time as objects move or change in the video
feed.
✔​ Provides clear visual representation of object locations and sizes.

c.​ Labeling and Tracking–

✔​ Labels detected objects with their class (e.g., person, car, dog).
✔​ Tracks objects continuously across frames, even as they move.
✔​ Supports applications like security surveillance, robotic navigation,
and behavior analysis.

d.​ Multi-object Detection –

✔​ Detects multiple objects simultaneously within the same frame.
✔​ Can handle overlapping objects and distinguish between them.
✔​ Supports detection of various classes of objects (e.g., vehicles, people,
animals) in real time.

e.​ Adaptive Detection for Various Environments–

✔​ Adjusts detection sensitivity based on the environment (e.g., lighting,
motion).
✔​ Works effectively in diverse conditions such as day/night,
indoors/outdoors.
✔​ Adapts to varying object sizes and speeds in the video feed.
 f.​ Data Logging and Analysis –
✔​ Logs detected objects with timestamps, confidence scores, and
additional metadata.
✔​ Allows post-processing and analysis of detection results for
performance evaluation or trend analysis.
✔​ Stores logs locally or in the cloud for future reference and insights.

ii.​ Non-Functional Features:The system ensures high performance with low latency,
scalability, and reliability, providing seamless real-time object detection across
various environments.
a.​ Performance & Speed Optimization –
✔​ GPU Acceleration: Uses CUDA-compatible GPUs for faster inference.
✔​ Model Optimization: Reduces model size with pruning and
quantization for improved speed.
✔​ Parallel Processing: Utilizes multi-threading and batch processing for
faster frame handling.
b.​ Security & Data Privacy –
✔​ Local Processing: Data is processed locally to ensure privacy.

✔​ Access Control: User authentication limits access to sensitive data.

c.​ Scalability & Database Management –

✔​ Cloud Integration: Supports cloud storage for scalable data
management and backup.
✔​ Distributed Processing: Allows scaling across multiple devices or
GPUs for handling large video streams.
✔​ Database Flexibility: Supports both SQL and NoSQL databases for
efficient storage of detection results and logs.
.
d.​ Data Backup & Recovery –
✔​ Automated Backups: Regular automated backups of detection data and
models to prevent data loss.
✔​ Cloud Storage: Uses cloud storage for secure off-site backups and easy
retrieval.
 ✔​ Recovery Mechanism: Implements quick recovery protocols to restore
data in case of system failure

2.4​External Interface Requirements:

The system requires integration with video capture devices (e.g., cameras or IP streams)
for real-time data input. Additionally, it may interface with cloud storage or databases for
saving detection results, logs, and models.

2.4.1 User Interfaces:

The user interface provides real-time video feed display with detection results, including
bounding boxes and labels, for easy monitoring and interaction.
User Interface components:

Component Description Technology Used

Video Display Shows live video with detection OpenCV, Python (Tkinter)
annotations.
Detection Results Lists detected objects with class Python (Tkinter), Flask
and confidence.
Alert Notification Notifies users when specific Python(Tkinter),
objects are detected. WebSocket
Control Panel Provide start /stops control and Python (Tkinter),
setting adjustment. HTML/CSS
Data Logging Displays and exports detection SQLite, Flask
logs.

2.4.2 Hardware Interfaces:

The system requires specific hardware components to function correctly.

Hardware Component Purpose Minimum Requirement

Camera (Webcam or Captures real-time images 720p resolution or higher
External) for face recognition.
Computer/Laptop Runs the attendance Intel i3 (or equiv) with
system. 4GB RAM
Storage Stores user details and Minimum 500MB
attendance logs. available.

2.4.3 Software Interfaces:

The system uses PyTorch and OpenCV for detection and processing, with optional
integration of Flask and databases for UI and data management.
Required Software & Libraries –
 Software Purpose Version
Python Main Programming language Python 3.x
OpenCV(cv2) Video capture and image processing OpenCV 4.x
NumPy Image data processing NumPy 1.x
PyTorch Deep learning framework for YOLO 1.12 or above
mode
YOLO Object detection model framework Latest stable
MySQL Server Stores user details and attendance MySQL 8.x or later
records
MySQL Connector Allows Python to interact with mysql-connector-python
MySQL

2.4.4 Communication Interfaces:

The system communicates internally between different modules and externally with
databases, cameras, and storage systems.

❖​ Internal Communication:
o​ Camera → Detector: Capture
o​ Detector → Post-process: Inference
o​ Post-process → UI/Alerts/Logs: Dispatch

❖​ External Communication (Database & File Handling):

Component Type Purpose Technology Used

Detection Logger Database Store detection metadata SQLite

Video Archiver File Store raw or annotated MP4via OpenCv

Storage video streams

Camera External Captures real-time images OpenCV(cv2)

(Webcam) for face recognition

2.5 Other Nonfunctional Requirements:

2.5.1 Performance Requirements:
The system should operate efficiently and accurately, processing real time object detection
and detect the object within seconds.
Key Performance Metrics-

✔​ FPS (Frames Per Second) – Measures real-time processing speed. Higher is better.

✔​ Inference Time – Time YOLO takes to detect objects in a single frame.

 ✔​ mAP (Mean Average Precision) – Overall accuracy of object detection across
classes.
✔​ Precision & Recall – Precision shows how accurate detections are, recall shows how
many real objects are found.
✔​ System Resource Usage – Tracks CPU, GPU, and memory usage during detection.

2.5.2 Safety Requirements:

The system should be safe to use and should protect user data from unauthorised access.
Key Safety Measures:

✔​ Secure Data – Encrypt streams & stored data, use HTTPS.

✔​ Fail-Safe – Handle crashes, auto-restart services.

✔​ Access Control – Restrict system/API access with authentication.

2.5.3 Security Requirements:

The system should ensure data security and prevent unauthorized access.
Security Measures:

✔​ Encrypted Communication – Use HTTPS, SSL/TLS for video streams and API
calls.

✔​ Authentication & Authorization – Secure access with API keys, tokens, or

role-based access.

✔​ Secure Data Storage – Encrypt stored files, logs, and detection data; use secure
cloud storage.

2.5.4 Software Quality Attributes:

The system should be reliable, maintainable, scalable, and efficient.
1.​ Performance – Ensure fast detection (low latency, high FPS) and efficient use of
system resources (CPU, GPU, memory).
2.​ Scalability – Design the system to handle varying loads, from individual cameras to
multiple streams or higher-resolution inputs.
3.​ Reliability – Implement error handling, failover mechanisms, and robustness to
ensure consistent performance under different conditions.
 Chapter 3 – System Design
3.1​ Flowchart:

Fig: 3.1
3.2​ ER Diagram:

Fig: 3.2

3.3​ Design Methodology:

Layer Function Technologies Used
Presentation Layer (GUI) User interface and HTML, CSS, JavaScript,
interaction. Streamlit, OpenCV GUI
Application Layer Coordinate logic, process Python, Flask/FastAPI,
images, manage flow Node.js
Data Storage Layer Save logs, results, images, SQLite, Firebase, Local
model weights. Storage
3.4​ Software Development Model:

Fig: 3.4

1. Planning – Set goals, pick tools, and outline the project.

2. Development – Build the detection system with video input.
3. Testing – Check accuracy and fix issues.
4. Deployment – Launch and optimize the app.
5. Maintenance – Update, monitor, and improve over time.
Example: If the admin request new reporting features, the system can be updated without
a complete redesign.

3.5​ Database Design:

3.5.1​ Users Table –Stores information about users interacting with the system..

Column Name Data Type Constraints

user_id INT PRIMARY KEY

username VARCHAR (50) NOT NULL, UNIQUE

email VARCHAR (100) NOT NULL, UNIQUE

password_hash VARCHAR(255) NOT NULL

created_at DATETIME DEFAULT CURRENT_

TIMESTAMP
3.5.2​ Detection_sessions–Stores metadata about each object detection session.

Column Name Data Type Constraints

session_id INT PRIMARY KEY

user_id INT FOREIGN KEY

session_name VARCHAR(100) NOT NULL

start_time DATETIME DEFAULT

CURRENT_TIMESTAMP

end_time DATETIME NULL

3.6 DFDs:

Fig: 3.6.1
Fig: 3.6.2

Fig: 3.6.3
3.7 Activity Diagram:

Fig: 3.7

3.8 Class Diagram:

Fig: 3.8
3.9 Sequence Diagram:

Fig: 3.8
 Chapter 4 – System Implementation

4.1 Coding:
4.1.1 Import:

4.1.2 Class Definition: ObjectDetector:

4.1.3 Initialization (init method):

4.1.4 Setting up the YOLO Network:

4.1.5 Detection Function (detect_objects method):

4.1.6 Drawing Bounding Boxes (draw_bounding_boxes method):

4.1.7 Main Loop:

4.1.8 Signal Handling for Graceful Exit:

4.2 Testing:

4.3 Snapshot:
 Chapter 5 – Conclusion and future Scope
5.1 Conclusion:

The implementation of real-time object detection using YOLO (You Only Look Once) and
OpenCV has demonstrated the capability to accurately and efficiently detect multiple objects
within video streams. YOLO's fast inference time, combined with OpenCV’s flexible image
processing capabilities, enabled a seamless and responsive detection system suitable for
real-world applications. This project highlights the practicality of deep learning-based object
detection for use cases such as surveillance, autonomous systems, and smart vision
applications. Future improvements may include model optimization, deployment on edge
devices, and integration with other AI-based decision-making systems.

Key Achievements of the Project:

●​ Successful Integration of YOLO with OpenCV

●​ Real-Time Detection Performance
●​ Multi-Class Object Recognition
●​ Efficient Resource Utilization
●​ Scalable and Extensible Framework
●​ Visualization and Feedback
●​ Potential for Real-World Deploymen

The project demonstrated high efficiency by achieving real-time object detection with
minimal latency and accurate results. Leveraging YOLO's speed and OpenCV’s processing
capabilities, it maintained a high frame rate while efficiently utilizing system resources. The
use of lightweight model variants ensured low memory consumption, making the system
suitable even for hardware-constrained environments. Overall, the architecture proved
scalable, responsive, and reliable for practical deployment.

5.2 Future Scope:

While the system is fully functional, several enhancements can be made to improve
performance, security, and scalability.

●​ Upgrade to Advanced YOLO Versions:​

Future iterations of the project can incorporate newer YOLO models like YOLOv5,
YOLOv7, or YOLOv8, which offer improved accuracy, better speed, and lighter
architectures, enhancing overall performance.​

●​ Edge Device Deployment:​

The system can be deployed on edge computing platforms such as Raspberry Pi,
NVIDIA Jetson Nano, or Coral TPU, enabling real-time object detection in portable,
low-power environments without relying on powerful GPUs.​
●​ Object Tracking and Anomaly Detection:​
Adding object tracking (e.g., Deep SORT) will help follow objects across frames,
while anomaly detection can provide alerts for unusual behaviors or restricted object
movement, improving security and automation.​

●​ Real-Time Alerts and Notifications:​

Integrating alert mechanisms (via SMS, email, or push notifications) based on
detection events can enhance the system's usefulness for applications like
surveillance, intrusion detection, or traffic violations.​

●​ Custom Dataset Training:​

By training YOLO on domain-specific datasets, the system can be adapted for
specialized applications such as detecting defective products in manufacturing, plant
diseases in agriculture, or customer behavior in retail.​

●​ Video Analytics and Reporting:​

Implementing analytics features (e.g., counting, heatmaps, dwell time analysis) will
provide valuable insights for sectors like smart cities, public safety, and marketing.​

●​ Cloud Integration and Remote Access:​

Uploading data and detection results to cloud platforms can allow for centralized
monitoring, remote access, long-term storage, and integration with other AI systems
or dashboards.​

●​ Graphical User Interface (GUI):​

Developing a user-friendly GUI will allow non-technical users to operate, configure,
and monitor the system easily, making it more accessible for widespread use.
 Chapter 6 – References
●​ OpenCV: https://docs.opencv.org/4.x/d6/d00/tutorial_py_root.html
●​ YOLO (You Only Look Once) Original Paper​
Redmon, J., Divvala, S., Girshick, R., & Farhadi, A. (2016). You Only
Look Once: Unified, Real-Time Object Detection
https://arxiv.org/abs/1506.02640
●​ OpenCV Documentation​
Bradski, G. (2000). The OpenCV Library.​
https://docs.opencv.org/
●​ COCO Dataset​
Lin, T. Y., Maire, M., Belongie, S., Hays, J., Perona, P., Ramanan, D.,
... & Dollár, P. (2014). Microsoft COCO: Common Objects in Context.​
https://cocodataset.org/
●​ Real-Time Object Detection using YOLO with OpenCV​
Soni, P., & Rane, P. (2021). Real-Time Object Detection using YOLO
with OpenCV.​
https://towardsdatascience.com/real-time-object-detection-using-yolo
-with-opencv-c58268c5e8b7
●​ Real-Time Object Detection: A Comparative Review of YOLO, SSD,
and Faster R-CNN​
Wu, Y., & Neumann, P. (2020). A Comparative Review of YOLO, SSD,
and Faster R-CNN for Real-Time Object Detection.​
https://arxiv.org/abs/2002.09378