CREDIT SYSTEM USING FACIAL

RECOGNITION
A Major Project Report Submitted
In partial fulfillment of the requirements for the award of the degree of

Bachelor of Technology
in
Computer Science and Engineering

by
M V N S Mukul Datta 16N31A05B3
Rameshwaram Avinash 17N31A05K3
Amblam Sreekar 16N31A0508

Under the esteemed guidance of

Mr. P. BIKSHAPATHY
Associate Professor

Department of Computer Science and Engineering

Malla Reddy College of Engineering & Technology
(Autonomous Institution- UGC, Govt. of India)
(Affiliated to JNTUH, Hyderabad, Approved by AICTE, NBA &NAAC with ‘A’
Grade)
Maisammaguda, Kompally, Dhulapally, Secunderabad – 500100
website: www.mrcet.ac.in

2017-2021

1
CREDIT SYSTEM USING FACIAL
RECOGNITION
A Major Project Report Submitted
In partial fulfillment of the requirements for the award of the degree of

Bachelor of Technology
in
Computer Science and Engineering

by
M V N S Mukul Datta 16N31A05B3
Rameshwaram Avinash 17N31A05K3
Ambalam Sreekar 16N31A0508

Under the esteemed guidance of

Mr. P. BIKSHAPATHY
Associate Professor

Department of Computer Science and Engineering

Malla Reddy College of Engineering & Technology
(Autonomous Institution- UGC, Govt. of India)
(Affiliated to JNTUH, Hyderabad, Approved by AICTE, NBA &NAAC with ‘A’
Grade)
Maisammaguda, Kompally, Dhulapally, Secunderabad – 500100
website: www.mrcet.ac.in

2017-2021

2
Malla Reddy College of Engineering & Technology
(Autonomous Institution- UGC, Govt. of India)
(Affiliated to JNTUH, Hyderabad, Approved by AICTE, NBA &NAAC with ‘A’
Grade)
Maisammaguda, Kompally, Dhulapally, Secunderabad – 500100
website: www.mrcet.ac.in

CERTIFICATE

This is to certify that this is the bonafide record of the major project entitled “Credit System

using Facial Recognition”, submitted by M V N S Mukul Datta (16N31A05B3),

Rameshwaram Avinash (17N31A05K3) and Amblam Sreekar (16N31A0508) of B.Tech

in the partial fulfillment of the requirements for the degree of Bachelor of Technology in

Computer Science and Engineering, Department of Computer Science and Engineering

during the year 2020-2021. The results embodied in this major project report have not been

submitted to any other university or institute for the award of any degree or diploma.

Internal Guide Head of the Department

Mr. P. Bikshyapathy Dr. T Venu Gopal
Associate Professor Professor

External Examiner

3
DECLARATION

We hereby declare that the major project titled “Credit System using Facial

Recognition” submitted to Malla Reddy College of Engineering and Technology

(UGC Autonomous), affiliated to Jawaharlal Nehru Technological University

Hyderabad (JNTUH) for the award of the degree of Bachelor of Technology in

Computer Science and Engineering is a result of original research carried-out in this

thesis. It is further declared that the major project report or any part thereof has not

been previously submitted to any University or Institute for the award of degree or

diploma.

M V N S Mukul Datta - 16N31A05B3

Rameshwaram Avinash - 17N31A05K3
Ambalam Sreekar - 16N31A0508

4
ACKNOWLEDGEMENT

We feel ourselves honored and privileged to place our warm salutation to our college Malla
Reddy College of Engineering and Technology (UGC-Autonomous), our Director Dr. VSK
Reddy and Principal Dr S Srinivasa Rao who gave us the opportunity to have experience in
engineering and profound technical knowledge.

We express our heartiest thanks to our Head of the Department Dr. T Venu Gopal for
encouraging us in every aspect of our project and helping us realize our full potential.

We would like to thank our internal guide and Project Coordinator Mr. P Bikshyapathy for
his regular guidance and constant encouragement. We are extremely grateful to his valuable
suggestions and unflinching co-operation throughout project work.

We would like to thank our class in charge Mr. N. Siva Kumar who in spite of being busy
with his duties took time to guide and keep us on the correct path.

We would also like to thank all the supporting staff of the Department of CSE and all other
departments who have been helpful directly or indirectly in making our project a success.

We are extremely grateful to our parents for their blessings and prayers for the completion of
our project that gave us strength to do our project.

with regards and gratitude

M V N S Mukul Datta - 16N31A05B3

Rameshwaram Avinash - 17N31A05K3
Ambalam Sreekar - 16N31A0508

5
ABSTRACT

Now a days every shopping mall or supermarket has credit points when we purchase anything
from the store and we can later redeem them for benefits. The process requires the customers
to fill in a form and submit details which is why many of the customers refrain from
becoming members, we plan to automate it using a facial recognition software which
identifies customers.
The software identifies faces which are already recognized and automatically adds the credit
points to the customer’s account. If the customer is not found, then the system requests the
customer picture and contact details for customer to be added to the database. The points can
be redeemed as the company pleases. The system uses OpenCV and Deep Learning Concepts
to recognize and remember a face and then stores or retrieves the data from the local
database.
Each customer has a separate folder to themselves which avoids confusion of adding and the
credit points automatically. This enables for faster processing and also gives the customers an
advantage of benefit. As it reduces the need of entering of information from the customer
because the system automatically identifies the customer and displays the details when the
purchase is made it automatically adds the credit points to the customer’s data which helps in
faster processing and less manual labor. The system can also be expanded in future for more
additions and can also be added to existing systems as a plugin.

6
TABLE OF CONTENTS

S.NO TITTLE PG.NO

1 INTRODUCTION 11
1.1 PURPOSE, AIM AND OBJECTIVES 11
1.2 BACKGROUND OF PROJECT 11
1.3 SCOPE OF PROJECT 12
1.4 MODULES DESCRIPTION 13

2 SYSTEM ANALYSIS 13
2.1 HARDWARE AND SOFTWARE REQUIREMENTS 14
2.2 SOFTWARE REQUIREMENTS SPECIFICATION 15

3 TECHNOLOGIES USED 16
3.1 PYTHON 16
3.2 PYQT5 20

4 SYSTEM DESIGN & UML DIAGRAMS 22

4.1 SOFTWARE DESIGN 23
4.2 ARCHITECTURE 25
4.3 UNIFIED MODELING LANGUAGE 27

5 INPUT/OUTPUT DESIGN 28
5.1 INPUT DESIGN 28
5.2 OUTPUT DESIGN 28

6 IMPLEMENTATION 29

7 TESTING 34
7.1 TESTING OBJECTIVES 34
7.2 TESTING METHODOLOGIES 35
7.3 USER TRAINING 35
7.4 MAINTAINENCE 37
7.5 TESTING STRATEGY 38
7.6 TEST CASES 40

8 OUTPUT SCREENS 43

9 CONCLUSION & FUTURE SCOPE 45

10 BIBLIOGRAPHY 46

7
LIST OF TABLES

TABLE.NO NAME PG.NO

3.1.1 FACIAL RECOGNITION 40

7.6.1 CREDITS ADD TEST CASE 40

7.6.2 REGISTRATION TEST CASE 41

7.6.3 NEW USER REGISTRATION TEST CASE 41

8
LIST OF FIGURES

FIGURE.NO NAME
PAGE.NO
6
Fig 2.1 Spiral Model

System 9
Fig 3.1 Architecture
Design
17
Fig 3.2 Use Case Diagram

18
Fig 3.3 Activity Diagram

State Chart 19
Fig 3.4 Diagram

9
LIST OF OUTPUTS

FIGURE.NO NAME PG.NO

8.1 HOME SCREEN 43

82. FACIAL RECOGNITION 43

8.3 ADD CREDITS 44

8.4 REGISTER A NEW USER 44

10
1. INTRODUCTION

This chapter gives an overview about the purpose, aim, objectives, background and
operation environment of the system.

1.1 PURPOSE, AIM AND OBJECTIVES:

Auto Credit system is an application which can be used to record the credit points of a
customer and add them to the customer’s account after identifying the customers faces using
OpenCV and deep learning.
 Reduces the time consumed to add and register new customers.
 Plans to make easier storage and access for customer credits when shopping.
 Makes faster transactions.
 Can be a plugin as well as a standalone application.

1.2 BACKGROUND OF PROJECT:

The background of the project takes its idea from an article which encourages facial
recognition and faster processing to process customer requests and also disable the need of
manual processing. Usually the process requires the customers to fill in a form and submit
details which is why many of the customers refrain from becoming members, we plan to
automate it using a facial recognition software which identifies customers based on images
stored in the database and uses them to process the current face in front of the camera.

1.2 SCOPE OF PROJECT:

The developed system consists of facial recognition which identifies the customers
based on the webcam placed near the checkout which enables for faster checkout and
reduction of unnecessary manual labour. The system uses OpenCV and deep learning to
process the data and learn faster then uses a local database to store the collected data. The
system recognises the customer and then when a purchase is made it automatically adds
the credit points to the customer’s data which helps in faster processing and less manual
labour.

11
1.3 MODULES DESCRIPTION:

This project is composed of three main modules which also include sub modules:

1. Facial recognition system: The main component of our system which is used to
recognizes the faces which appear on the webcam.
2. Register Module: When the system identifies an unknown face, the register
button the screen is used to capture the image of the face and store it in the
database for the registration purpose of the customer.
3. Credit Manager: This module deals with the management of the credit points the
customer has and then displays the credits on the screen and the add credits button
is used to add the credits to the existing customer.

These are the important modules in the system and are the core modules which helps
us understand the basic working of the system.

12
2. SYSTEM ANALYSIS

In this chapter, we will discuss and analyze about the developing process of Audit
Control including software requirement specification (SRS) and comparison between existing
and proposed system. The functional and non-functional requirements are included in SRS
part to provide complete description and overview of system requirement before the
developing process is carried out. Besides that, existing vs. proposed provides a view of how
the proposed system will be more efficient than the existing one.

2.1 HARDWARE AND SOFTWARE REQUIREMENTS

2.1.1 HARDWARE REQUIREMENTS:

Processor : Intel or AMD.

Ram : 4 GB or above.
Hard disk : 50 GB or above.
Webcam : 10 pixel or above.

2.1.2 SOFTWARE REQUIREMENTS:

Technology/Language : Python.
Data Base : Local database.
Dlib/Cmake : version 17 and above.

13
2.2 SOFTWARE REQUIREMENT SPECIFICATION:

2.2.1 SRS:
Software Requirement Specification (SRS) is the starting point of the software
developing activity. As system grew more complex it became evident that the goal of the
entire system cannot be easily comprehended. Hence the need for the requirement phase
arose. The software project is initiated by the client needs. The SRS is the means of
translating the ideas of the minds of clients (the input) into a formal document (the output of
the requirement phase.)
The SRS phase consists of two basic activities:

1) Problem/Requirement Analysis:

The process is order and more nebulous of the two, deals with understand the
problem, the goal and constraints.
2) Requirement Specification:

Here, the focus is on specifying what has been found giving analysis such as
representation, specification languages and tools, and checking the specifications are
addressed during this activity.
The Requirement phase terminates with the production of the validate SRS document.
Producing the SRS document is the basic goal of this phase.

2.2.2 ROLE OF SRS:

The purpose of the Software Requirement Specification is to reduce the

communication gap between the clients and the developers. Software Requirement
Specification is the medium through which the client and user needs are accurately specified.
It forms the basis of software development. A good SRS should satisfy all the parties
involved in the system.

14
2.2.3 SCOPE:
This document is the only one that describes the requirements of the system. It is
meant for the use by the developers, and will also be the basis for validating the final
delivered system. Any changes made to the requirements in the future will have to go through
a formal change approval process. The developer is responsible for asking for clarifications,
where necessary, and will not make any alterations without the permission of the client.

2.2.4 EXISTING SYSTEM:

The system which currently exists is manual and it needs for the employee or
executive to enter the details of the customers and the system then retrieves the data
from the database. The system needs to take many details to store or give membership
to the customer which can make many customers have no interest or just be
uninteresting to them which can make it a bother for them. This also makes the
processing slower as it delays the working of the order and slows the processing
down, which can be avoided by our system.

2.2.4.1 DRAWBACKS OF EXISTING SYSTEM:

 A has to manually enter the details of the customer.

 There is possibly of customer declining as it takes a lot of time and is annoying.

2.2.5 PROPOSED SYSTEM:

The developed system consists of facial recognition which identifies the customers
based on the webcam placed near the checkout which enables for faster checkout and
reduction of unnecessary manual labour. The system uses OpenCV and deep learning
to process the data and learn faster then uses a local database to store the collected
data. The system recognises the customer and then when a purchase is made it
automatically adds the credit points to the customer’s data which helps in faster
processing and less manual labour. The system can also be expanded in future for
more additions and can also be added to existing systems as a plugin.

15
3. TECHNOLOGIES USED

3.1 PYTHON :

Python is an interpreted high-level general-purpose programming language.

Python's design philosophy emphasizes code readability with its notable use of significant
indentation. Its language constructs as well as its object-oriented approach aim to help
programmers write clear, logical code for small and large-scale projects.

Python is dynamically-typed and garbage-collected. It supports multiple

programming paradigms, including structured (particularly, procedural), object-oriented
and functional programming. Python is often described as a "batteries included" language
due to its comprehensive standard library.

Guido van Rossum began working on Python in the late 1980s, as a successor to
the ABC programming language, and first released it in 1991 as Python 0.9.0. Python 2.0
was released in 2000 and introduced new features, such as list comprehensions and a
garbage collection system using reference counting. Python 3.0 was released in 2008 and
was a major revision of the language that is not completely backward-compatible and
much Python 2 code does not run unmodified on Python 3. Python 2 was discontinued
with version 2.7.18 in 2020.

3.1.1 PYTHON DEVELOPMENT

Python's development is conducted largely through the Python Enhancement Proposal

(PEP) process, the primary mechanism for proposing major new features, collecting
community input on issues and documenting Python design decisions. Python coding style
is covered in PEP 8. Outstanding PEPs are reviewed and commented on by the Python
community and the steering council. Enhancement of the language corresponds with
development of the CPython reference implementation. The mailing list python-dev is the
primary forum for the language's development. Specific issues are discussed in the
Roundup bug tracker hosted at bugs.python.org. Development originally took place on a
self-hosted source-code repository running Mercurial, until Python moved to GitHub in
January 2017. Python’s public releases come in three types, distinguished by which part of

16
the version number is incremented: Backward-incompatible versions, where code is
expected to break and need to be manually ported. The first part of the version number is
incremented. These releases happen infrequently—for example, version 3.0 was released
8 years after 2.0.

Major or "feature" releases, about every 18 months, are largely compatible but
introduce new features. The second part of the version number is incremented. Each major
version is supported by bug fixes for several years after its release. Bug fix releases, which
introduce no new features, occur about every 3 months and are made when a sufficient
number of bugs have been fixed upstream since the last release. Security vulnerabilities
are also patched in these releases. The third and final part of the version number is
incremented. Python 3.9 alpha1 was announced in November 2019 and with the adoption
of a new yearly release cadence, the first release of 3.9 is slated for November 2020.
Many alpha, beta, and release-candidates are also released as previews and for testing
before final releases. Although there is a rough schedule for each release, they are often
delayed if the code is not ready. Python's development team monitors the state of the code
by running the large unit test suite during development, and using the BuildBot continuous
integration system. The major academic conference on Python is PyCon. There are also
special Python mentoring programmes, such as Pyladies

3.1.2 FEATURES OF PYTHON

Python is known for its general-purpose nature that makes it applicable in almost
every domain of software development. Python makes its presence in every emerging field. It
is the fastest-growing programming language and can develop any application.

Here, we are specifying application areas where Python can be applied.

3.1.2.1 PYTHON APPLICATIONS

1) Web Applications
We can use Python to develop web applications. It provides libraries to handle
internet protocols such as HTML and XML, JSON, Email processing, request, Beautiful
Soup, Feed parser, etc. One of Python web-framework named Django is used on Instagram.
Python provides many useful frameworks, and these are given below:
 Django and Pyramid framework (Use for heavy applications)

17
 Flask and Bottle (Micro-framework)
 Plone and Django CMS (Advance Content management)

2) Desktop GUI Applications

The GUI stands for the Graphical User Interface, which provides a smooth interaction
to any application. Python provides a Tk GUI library to develop a user interface. Some
popular GUI libraries are given below.
 Tkinter or Tk
 wxWidgetM
 Kivy (used for writing multitouch applications)
 PyQt or Pyside

3) Console-based Application
Console-based applications run from the command-line or shell. These
applications are computer program which are used commands to execute. This kind of
application was more popular in the old generation of computers. Python can develop this
kind of application very effectively. It is famous for having REPL, which means the Read-
Eval-Print Loop that makes it the most suitable language for the command-line applications.
Python provides many free library or module which helps to build the command-line apps.
The necessary IO libraries are used to read and write. It helps to parse argument and create
console help text out-of-the-box. There are also advance libraries that can develop
independent console apps.

4) Software Development
Python is useful for the software development process. It works as a support language
and can be used to build control and management, testing, etc.
SCons is used to build control.
BuildBot and Apache Gumps are used for automated continuous compilation and testing.
Round or Trac for bug tracking and project management.

5) Scientific and Numeric

This is the era of Artificial intelligence where the machine can perform the task the
same as the human. Python language is the most suitable language for Artificial intelligence
or machine learning. It consists of many scientific and mathematical libraries, which makes
easy to solve complex calculations.

18
Implementing machine learning algorithms require complex mathematical calculation.
Python has many libraries for scientific and numeric such as NumPy, Pandas, SciPy, Scikit-
learn, etc. If you have some basic knowledge of Python, you need to import libraries on the
top of the code. Few popular frameworks of machine libraries are given below.
 SciPy
 Scikit-learn
 NumPy
 Pandas
 Matplotlib

6) Business Applications
Business Applications differ from standard applications. E-commerce and ERP are an
example of a business application. This kind of application requires extensively, scalability
and readability, and Python provides all these features.

Oddo is an example of the all-in-one Python-based application which offers a range of

business applications. Python provides a Tryton platform which is used to develop the
business application.

7) Audio or Video-based Applications

Python is flexible to perform multiple tasks and can be used to create multimedia
applications. Some multimedia applications which are made by using Python are Tim Player,
cplay, etc. The few multimedia libraries are given below.
 Gstreamer
 Pyglet
 QT Phonon

8) 3D CAD Applications
The CAD (Computer-aided design) is used to design engineering related architecture.
It is used to develop the 3D representation of a part of a system. Python can create a 3D CAD
application by using the following functionalities.
 Fandango (Popular)
 CAMVOX
 HeeksCNC
 AnyCAD
 RCAM

19
9) Enterprise Applications
Python can be used to create applications that can be used within an Enterprise or an
Organization. Some real-time applications are OpenERP, Tryton, Picalo, etc.

10) Image Processing Application

Python contains many libraries that are used to work with the image. The image can
be manipulated according to our requirements. Some libraries of image processing are given
below.

 OpenCV
 Pillow
 SimpleITK

These are all types of applications where Python plays an essential role in the development of
these applications.
3.2 PYQT5:
3.3
PyQt is a Python binding of the cross-platform GUI toolkit Qt, implemented as a
Python plug-in. PyQt is free software developed by the British firm Riverbank
Computing. It is available under similar terms to Qt versions older than 4.5; this means
a variety of licenses including GNU General Public License (GPL) and commercial
license, but not the GNU Lesser General Public License (LGPL). PyQt supports
Microsoft Windows as well as various flavours of UNIX, including Linux and MacOS
(or Darwin).

3.2.1 : PYQT MAIN COMPONENTS:

PyQt4 contains the following Python modules.

The QtCore module contains the core non-GUI classes, including the event loop and
Qt's signal and slot mechanism. It also includes platform independent abstractions for
Unicode, threads, mapped files, shared memory, regular expressions, and user and
application settings. The QtGui module contains the majority of the GUI classes. These
include a number of table, tree and list classes based on the model–view–controller
design pattern. Also provided is a sophisticated 2D canvas widget capable of storing
thousands of items including ordinary widgets.

20
The QtNetwork module contains classes for writing UDP and TCP clients and servers.
It includes classes that implement FTP and HTTP clients and support DNS lookups.
Network events are integrated with the event loop making it very easy to develop
networked applications. The QtOpenGL module contains classes that enable the use of
OpenGL in rendering 3D graphics in PyQt applications.
The QtSql module contains classes that integrate with open-source and proprietary SQL
databases. It includes editable data models for database tables that can be used with
GUI classes. It also includes an implementation of SQLite.
The QtSvg module contains classes for displaying the contents of SVG files. It supports
the static features of SVG 1.2 Tiny.
The QtXml module implements SAX and DOM interfaces to Qt's XML parser.
The QtMultimedia module implements low-level multimedia functionality. Application
developers would normally use the phonon module.
The QtDesigner module contains classes that allow Qt Designer to be extended using
PyQt.
The Qt module consolidates the classes contained in all of the modules described above
into a single module. This has the advantage that you don't have to worry about which
underlying module contains a particular class. It has the disadvantage that it loads the
whole of the Qt framework, thereby increasing the memory footprint of an application.
Whether you use this consolidated module, or the individual component modules is
down to personal taste.
The uic module implements support for handling the XML files created by Qt Designer
that describe the whole or part of a graphical user interface. It includes classes that load
an XML file and render it directly, and classes that generate Python code from an XML
file for later execution.
PyQt5 contains the following Python modules:

• QtQml Module
• QtQtuick Module
• QtCore Module
• QtGui Module
• QtPrintSupport Module
• QtWidgets Module
• QGLContext Module
• QGLFormat Module
• QGLWidget Module
• QtWebKit Module
• QtWebKitWidgets Module

21
4.3 UNIFIED MODELING LANGUAGE (UML) :

The unified modeling is a standard language for specifying, visualizing, constructing

and documenting the system and its components is a graphical language which provides a
vocabulary and set of semantics and rules. The UML focuses on the conceptual and physical
representation of the system. It captures the decisions and understandings about systems that
must be constructed. It is used to understand, design, configure and control information about
the systems.
Depending on the development culture, some of these artifacts are treated more or less
formally than others. Such artifacts are not only the deliverables of a project; they are also
critical in controlling, measuring, and communicating about a system during its development
and after its deployment.
The UML addresses the documentation of a system's architecture and all of its details.
The UML also provides a language for expressing requirements and for tests. Finally, the
UML provides a language for modeling the activities of project planning and release
management.
4.3.1 BUILDING BLOCKS OF UML:

The vocabulary of the UML encompasses three kinds of building blocks:

 Things.
 Relationships.
 Diagrams.

4.3.1.1 Things in the UML:

Things are the abstractions that are first-class citizens in a model; relationships tie
these things together; diagrams group interesting collections of things.
There are four kinds of things in the UML:
 Structural things.
 Behavioral things.
 Grouping things.
 Annotational things.
1. Structural things are the nouns of UML models. The structural things used in the
project design are:

22
 First, a class is a description of a set of objects that share the same attributes,
operations, relationships and semantics.

Window
origin
size
open()
close()
move()
display()

Fig: Classes
 Second, a use case is a description of set of sequence of actions that a system
performs that yields an observable result of value to particular actor.

Fig: Use Cases

 Third, a node is a physical element that exists at runtime and represents a
computational resource, generally having at least some memory and often
processing capability.

Fig: Nodes
2. Behavioral things are the dynamic parts of UML models. The behavioral thing used
is:
 Interaction: An interaction is a behavior that comprises a set of messages
exchanged among a set of objects within a particular context to accomplish a
specific purpose. An interaction involves a number of other elements,
including messages, action sequences (the behavior invoked by a message, and
links (the connection between objects).

23
Fig: Messages

4.3.1.2 Relationships in the UML:

There are four kinds of relationships in the UML:
 Dependency.
 Association.
 Generalization.
 Realization.

 A dependency is a semantic relationship between two things in which a change to

one thing may affect the semantics of the other thing (the dependent thing).

Fig: Dependencies
 An association is a structural relationship that describes a set links, a link being a
connection among objects. Aggregation is a special kind of association, representing a
structural relationship between a whole and its parts.

Fig: Association
 A generalization is a specialization/ generalization relationship in which objects of
thespecialized element (the child) are substitutable for objects of the generalized
element(the parent).

Fig: Generalization
 A realization is a semantic relationship between classifiers, where in one classifier
specifies a contract that another classifier guarantees to carry out.

Fig: Realization

24
4.3.2 UML DIAGRAMS:

4.3.2.2 USE CASE DIAGRAM:

A use case diagram is a graph of actors set of use cases enclosed by a system
boundary, communication associations between the actors and users and generalization
among use cases. The use case model defines the outside (actors) and inside (use case) of the
system’s behavior.

FIGURE 4.3.2.2: USE CASE DIAGRAM

4.3.2.3 SEQUENCE DIAGRAM:

Sequence diagram are used to represent the flow of messages, events and actions
between the objects or components of a system. Time is represented in the vertical direction
showing the sequence of interactions of the header elements, which are displayed
horizontally at the top of the diagram.

25
FIGURE 4.3.2.3.1: SEQUENCE DIAGRAM FOR USER

4.3.2.6 COMPONENT DIAGRAM:

In the Unified Modeling Language, a Component diagram depicts how components

are wired together to form larger components and or software systems. They are used to
illustrate the structure of arbitrarily complex systems.

26
FIGURE 4.3.2.6: COMPONENT DIAGRAM

4.3.2.7 DEPLOYMENT DIAGRAM:

Deployment diagrams are used to visualize the topology of the physical components
of a system where the software components are deployed. So deployment diagrams are used
to describe the static deployment view of a system. Deployment diagrams consist of nodes
and their relationships.

FIGURE 4.3.2.7: DEPLOYMENT DIAGRAM

27
5. INPUT/OUTPUT DESIGN

5.1 INPUT DESIGN:

Input Design plays a vital role in the life cycle of software development, it requires
very careful attention of developers. The input design is to feed data to the application as
accurate as possible. So inputs are supposed to be designed effectively so that the errors
occurring while feeding are minimized. According to Software Engineering Concepts, the
input forms or screens are designed to provide to have a validation control over the input
limit, range and other related validations.Input design is the process of converting the user
created input into a computer-based format. The goal of the input design is to make the data
entry logical and free from errors.

Validations are required for each data entered. Whenever a user enters an erroneous
data, error message is displayed and the user can move on to the subsequent pages after
completing all the entries in the current page.

5.2 OUTPUT DESIGN:

The Output from the computer is required to mainly create an efficient method of
communication within the company primarily among the project leader and his team
members, in other words, the administrator and the clients. The output of VPN is the system
which allows the project leader to manage his clients in terms of creating new clients and
assigning new projects to them, maintaining a record of the project validity and providing
folder level access to each client on the user side depending on the projects allotted to him.
After completion of a project, a new project may be assigned to the client. User
authentication procedures are maintained at the initial stages itself.

28
6. IMPLEMENTATION

6.1 Mainwindow.py File:

import sys
from PyQt5.uic import loadUi
from PyQt5 import QtWidgets
from PyQt5.QtCore import pyqtSlot
from PyQt5.QtWidgets import QApplication, QDialog
import resource
# from model import Model
from out_window import Ui_OutputDialog

class Ui_Dialog(QDialog):
def __init__(self):
super(Ui_Dialog, self).__init__()
loadUi("mainwindow.ui", self)

self.runButton.clicked.connect(self.runSlot)

self._new_window = None
self.Videocapture_ = None

def refreshAll(self):
"""
Set the text of lineEdit once it's valid
"""
self.Videocapture_ = "0"

@pyqtSlot()
def runSlot(self):
"""
Called when the user presses the Run button
"""
print("Clicked Run")
self.refreshAll()
print(self.Videocapture_)
ui.hide() # hide the main window
self.outputWindow_() # Create and open new output window

def outputWindow_(self):

29
"""
Created new window for vidual output of the video in GUI
"""
self._new_window = Ui_OutputDialog()
self._new_window.show()
self._new_window.startVideo(self.Videocapture_)
print("Video Played")

if __name__ == "__main__":
app = QApplication(sys.argv)
ui = Ui_Dialog()
ui.show()
sys.exit(app.exec_())

6.2 Outputwindow.py:
import datetime

import os

import cv2

import face_recognition

import numpy as np

from PyQt5.QtCore import pyqtSlot, QTimer

from PyQt5.QtGui import QImage, QPixmap

from PyQt5.QtWidgets import QDialog, QMessageBox

from PyQt5.uic import loadUi

class Ui_OutputDialog(QDialog):

def __init__(self):

super(Ui_OutputDialog, self).__init__()

loadUi("./outputwindow.ui", self)

self.image = None

30
@pyqtSlot()

def startVideo(self, camera_name):

"""

:param camera_name: link of camera or usb camera

:return:

"""

if len(camera_name) == 1:

self.capture = cv2.VideoCapture(int(camera_name))

else:

self.capture = cv2.VideoCapture(camera_name)

self.timer = QTimer(self) # Create Timer

path = 'ImagesRecognise'

if not os.path.exists(path):

os.mkdir(path)

# known face encoding and known face name list

images = []

self.class_names = []

self.encode_list = []

self.Credit_List1 = []

self.Credit_List2 = []

attendance_list = os.listdir(path)

# print(attendance_list)

for cl in attendance_list:

cur_img = cv2.imread(f'{path}/{cl}')

images.append(cur_img)

self.class_names.append(os.path.splitext(cl)[0])

31
for img in images:

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

boxes = face_recognition.face_locations(img)

encodes_cur_frame = face_recognition.face_encodings(img, boxes)[0]

# encode = face_recognition.face_encodings(img)[0]

self.encode_list.append(encodes_cur_frame)

self.timer.timeout.connect(self.update_frame) # Connect timeout to the output function

self.timer.start(40) # emit the timeout() signal at x=40ms

def face_rec_(self, frame, encode_list_known, class_names):

"""

:param frame: frame from camera

:param encode_list_known: known face encoding

:param class_names: known face names

:return:

"""

# csv

def mark_attendance(name):

"""

:param name: detected face known or unknown one

:return:

"""

if self.AddCred.isCheked():

self.AddCred.setEnable(False)

with open('Customer Details.csv', 'a') as f:

if(name != 'unknown'):

32
buttonReply = QMessageBox.question(self, 'Add Credit points',
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)

date_time_string = datetime.datetime.now().strftime("%y/%m/%d
%H:%M:%S")

f.writelines(f'\n{name},{date_time_string}')

# face recognition

faces_cur_frame = face_recognition.face_locations(frame)

encodes_cur_frame = face_recognition.face_encodings(frame, faces_cur_frame)

# count = 0

for encodeFace, faceLoc in zip(encodes_cur_frame, faces_cur_frame):

match = face_recognition.compare_faces(encode_list_known, encodeFace,

tolerance=0.50)

face_dis = face_recognition.face_distance(encode_list_known, encodeFace)

name = "unknown"

best_match_index = np.argmin(face_dis)

# print("s",best_match_index)

if match[best_match_index]:

name = class_names[best_match_index].upper()

y1, x2, y2, x1 = faceLoc

cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)

cv2.rectangle(frame, (x1, y2 - 20), (x2, y2), (0, 255, 0), cv2.FILLED)

cv2.putText(frame, name, (x1 + 6, y2 - 6), cv2.FONT_HERSHEY_COMPLEX,

0.5, (255, 255, 255), 1)

mark_attendance(name)

return frame

def update_frame(self):

ret, self.image = self.capture.read()

33
self.displayImage(self.image, self.encode_list, self.class_names, 1)

def displayImage(self, image, encode_list, class_names, window=1):

"""

:param image: frame from camera

:param encode_list: known face encoding list

:param class_names: known face names

:param window: number of window

:return:

"""

image = cv2.resize(image, (640, 480))

try:

image = self.face_rec_(image, encode_list, class_names)

except Exception as e:

print(e)

qformat = QImage.Format_Indexed8

if len(image.shape) == 3:

if image.shape[2] == 4:

qformat = QImage.Format_RGBA8888

else:

qformat = QImage.Format_RGB888

outImage = QImage(image, image.shape[1], image.shape[0], image.strides[0], qformat)

outImage = outImage.rgbSwapped()

if window == 1:

self.imgLabel.setPixmap(QPixmap.fromImage(outImage))

self.imgLabel.setScaledContents(True)

34
7. TESTING

Software testing is a critical element of software quality assurance and represents the
ultimate review of specification, design and code generation.

7.1 TESTING OBJECTIVES:

• To ensure that during operation the system will perform as per specification.
• To make sure that system meets the user requirements during operation
• To make sure that during the operation, incorrect input, processing and output will be
detected
• To see that when correct inputs are fed to the system the outputs are correct
• To verify that the controls incorporated in the same system as intended
• Testing is a process of executing a program with the intent of finding an error
• A good test case is one that has a high probability of finding an as yet undiscovered
error

The software developed has been tested successfully using the following
testing strategies and any errors that are encountered are corrected and again the part
of the program or the procedure or function is put to testing until all the errors are
removed. A successful test is one that uncovers an as yet undiscovered error.

Note that the result of the system testing will prove that the system is working
correctly. It will give confidence to system designer, users of the system, prevent
frustration during implementation process etc.

7.2 TESTING METHODOLOGIES:

 White box testing.
 Black box testing.
 Unit testing.
 Integration testing.
 User acceptance testing.

35
 Output testing.
 Validation testing.
 System testing.
1) White Box Testing:

White box testing is a testing case design method that uses the control structure of the
procedure design to derive test cases. All independents path in a module are exercised at least
once, all logical decisions are exercised at once, execute all loops at boundaries and within
their operational bounds exercise internal data structure to ensure their validity. Here the
customer is given three chances to enter a valid choice out of the given menu. After which the
control exits the current menu.

2) Black Box Testing:

Black Box Testing attempts to find errors in following areas or categories, incorrect or
missing functions, interface error, errors in data structures, performance error and
initialization and termination error. Here all the input data must match the data type to
become a valid entry.

3) Unit Testing:

Unit testing focuses verification effort on the smallest unit of Software design that is
the module. Unit testing exercises specific paths in a module’s control structure to ensure
complete coverage and maximum error detection. This test focuses on each module
individually, ensuring that it functions properly as a unit. Hence, the naming is Unit Testing.

4) Integration Testing:

Integration testing addresses the issues associated with the dual problems of
verification and program construction. After the software has been integrated a set of high
order tests are conducted. The main objective in this testing process is to take unit tested
modules and builds a program structure that has been dictated by design.

The following are the types of Integration Testing:

 Top Down Integration:

36
This method is an incremental approach to the construction of program structure.
Modules are integrated by moving downward through the control hierarchy, beginning with
the main program module.
 Bottom Up Integration:

This method begins the construction and testing with the modules at the lowest level
in the program structure. Since the modules are integrated from the bottom up, processing
required for modules subordinate to a given level is always available and the need for stubs is
eliminated.

5) User acceptance Testing:

User Acceptance of a system is the key factor for the success of any system. The
system under consideration is tested for user acceptance by constantly keeping in touch with
the prospective system users at the time of developing and making changes wherever
required. The system developed provides a friendly user interface that can easily be
understood even by a person who is new to the system.

6) Output Testing:

After performing the validation testing, the next step is output testing of the proposed
system, since no system could be useful if it does not produce the required output in the
specified format. Asking the users about the format required by them tests the outputs
generated or displayed by the system under consideration. Hence the output format is
considered in 2 ways – one is on screen and another in printed format.

7) Validation Testing:

Validation testing is generally performed on the following fields:

 Text Field:

37
The text field can contain only the number of characters lesser than or equal to its
size. The text fields are alphanumeric in some tables and alphabetic in other tables. Incorrect
entry always flashes and error message.

 Numeric Field:

The numeric field can contain only numbers from 0 to 9. An entry of any character
flashes an error messages. The individual modules are checked for accuracy and what it has
to perform.

 Preparation of Test Data:

Taking various kinds of test data does the above testing. Preparation of test data plays
a vital role in the system testing. After preparing the test data the system under study is tested
using that test data. While testing the system by using test data errors are again uncovered
and corrected by using above testing steps and corrections are also noted for future use.

 Using Live Test Data:

Live test data are those that are actually extracted from organization files. After a
system is partially constructed, programmers or analysts often ask users to key in a set of data
from their normal activities. Then, the systems person uses this data as a way to partially test
the system. In other instances, programmers or analysts extract a set of live data from the files
and have them entered themselves.

 Using Artificial Test Data:

Artificial test data are created solely for test purposes, since they can be generated to
test all combinations of formats and values. In other words, the artificial data, which can
quickly be prepared by a data generating utility program in the information systems
department, make possible the testing of all login and control paths through the program.

38
The most effective test programs use artificial test data generated by persons other
than those who wrote the programs. Often, an independent team of testers formulates a
testing plan, using the systems specifications.

7.3 USER TRAINING:

Whenever a new system is developed, user training is required to educate them about
the working of the system so that it can be put to efficient use by those for whom the system
has been primarily designed. For this purpose the normal working of the project was
demonstrated to the prospective users. Its working is easily understandable and since the
expected users are people who have good knowledge of computers, the use of this system is
very easy.

7.4 MAINTAINENCE:

This covers a wide range of activities including correcting code and design errors. To
reduce the need for maintenance in the long run, we have more accurately defined the user’s
requirements during the process of system development. Depending on the requirements, this
system has been developed to satisfy the needs to the largest possible extent. With
development in technology, it may be possible to add many more features based on the
requirements in future. The coding and designing is simple and easy to understand which will
make maintenance easier.

7.5 TESTING STRATEGY :

A strategy for system testing integrates system test cases and design techniques into a
well planned series of steps that results in the successful construction of software. The testing
strategy must co-operate test planning, test case design, test execution, and the resultant data
collection and evaluation .A strategy for software testing must accommodate low-level tests
that are necessary to verify that a small source code segment has been correctly implemented
as well as high level tests that validate major system functions against user requirements.
Software testing is a critical element of software quality assurance and represents the
ultimate review of specification design and coding.

39
7.5.1 SYSTEM TESTING:
Software once validated must be combined with other system elements (e.g.
Hardware, people, database). System testing verifies that all the elements are proper and that
overall system function performance is achieved. It also tests to find discrepancies between
the system and its original objective, current specifications and system documentation.
7.5.2 UNIT TESTING:
In unit testing different are modules are tested against the specifications produced
during the design for the modules. Unit testing is essential for verification of the code
produced during the coding phase, and hence the goals to test the internal logic of the
modules. Using the detailed design description as a guide, important Conrail paths are tested
to uncover errors within the boundary of the modules. This testing is carried out during the
programming stage itself. In this type of testing step, each module was found to be working
satisfactorily as regards to the expected output from the module. In Due Course, latest
technology advancements will be taken into consideration. As part of technical build-up
many components of the networking system will be generic in nature so that future projects
can either use or interact with this.

7.6 TEST CASES:

Test Case 1: Identify face Priority (H, L): High

Test Objective: To identify the face

Test Description: Identify from the existing user

Requirements Verified: Yes

Test Environment: Application must be used.

Test Setup/Pre-Conditions:

Actions Expected Results

40
The face is identiofied Successfully identified

Pass: Yes Conditions pass: Yes Fail: No

Problems / Issues: NIL

Notes: Successfully Executed

TABLE 7.6.1:RECOGNITION TEST CASE

Test Case 2: Add credit points Priority (H, L): High

Test Objective: Adding the credits to the customer

Test Description: User should click on the add button and be able to add credit points

Requirements Verified: Yes

Test Environment: Application must be used.

Test Setup/Pre-Conditions:

Actions Expected Results

User clicks the button Successfully added points

Pass: Yes Conditions pass: Yes Fail: No

Problems / Issues: NIL

Notes: Successfully Executed

TABLE 7.6.2: CREDIT SYSTEM TEST CASE

Test Case 3: Register new user Priority (H, L): High

Test Objective: Register a new face

Test Description: User can add a new face to recognize.

41
Requirements Verified: Yes

Test Environment: Application must be used.

Test Setup/Pre-Conditions:

Actions Expected Results

The user must press the register button after entering the Successfully Recorded
credits

Pass: Yes Conditions pass: Yes Fail: No

Problems / Issues: NIL

Notes: Successfully Executed

TABLE 7.6.3: NEW USER REGISTRATION TEST CASE

42
8. OUTPUT SCREENS

8.1 Home Screen:

FIGURE 8.1: HOME SCREEN

8.2 IDENTIFY NEW FACE:

43
FIGURE 8.2: IDENTIFYING A FACE.
8.3 ADD CREDITS:

FIGURE 8.3: ADDING CREDITS.

8.4 REGISTER NEW USER:

FIGURE 8.4: REGISTER A NEW USER.

44
9.1 CONCLUSION:

This application will provide help not only to any shopping mall but will also help us
in making faster transactions and identification of customers which is rewarding for the
customer as well as the seller because it helps in faster processing and more rewards. The
data can be shared across servers which can help make the customer feel more easier and
faster access.
Considering impatience and restlessness of people nowadays the requirement of
having faster and seamless transactions is more and is demanding this application which is
developed aims to make the processing and checking in of customers easier and more
accessable.

9.2 FUTURE SCOPE:

• We currently aren’t using any database storage for faster retrieval and storage so we
would like to improve the project to use a global database which can be distributed
across the servers.
• The processing requires faster CPU as the performance was CPU bound and we plan
to include more algorithms for faster processing and enable more efficient recognition
• This enables the storage and access of data more easier and more efficient.

45
10. BIBLIOGRAPHY

10.1 WEBSITES:

 "https://www.eff.org/pages/face-recognitionwww.google.com
 https://medium.com/analytics-vidhya/a-take-on-h-o-g-feature-descriptor-
e839ebba1e52
 http://dlib.net/
 https://cmake.org/
 https://pypi.org/project/PyQt5/
 https://riverbankcomputing.com/software/pyqt/
 www.google.com

10.2 REFERENCES:

 "General Python FAQ — Python 3.9.2 documentation". docs.python.org. Retrieved

28 March 2021.
 ^ Jump up to:a b Guttag, John V. (12 August 2016). Introduction to Computation and
Programming Using Python: With Application to Understanding Data. MIT Press.
ISBN 978-0-262-52962-4.
 ^ Jump up to:a b "Python 3.8.10, 3.9.5, and 3.10.0b1 are now available". 3 May 2021.
Retrieved 4 May 2021.
 ^ "Why is Python a dynamic language and also a strongly typed language - Python
Wiki". wiki.python.org. Retrieved 27 January2021.
 ^ "PEP 483 -- The Theory of Type Hints". Python.org.
 ^ "Download Python". Python.org. Retrieved 24 May 2021.
 ^ File extension .pyo was removed in Python 3.5. See PEP 0488
 ^ Holth, Moore (30 March 2014). "PEP 0441 -- Improving Python ZIP Application
Support". Retrieved 12 November 2015.

46
 "General Python FAQ — Python 3.9.2 documentation". docs.python.org. Retrieved
28 March 2021.
 ^ Jump up to:a b Guttag, John V. (12 August 2016). Introduction to Computation and
Programming Using Python: With Application to Understanding Data. MIT Press.
ISBN 978-0-262-52962-4.
 ^ Jump up to:a b "Python 3.8.10, 3.9.5, and 3.10.0b1 are now available". 3 May 2021.
Retrieved 4 May 2021.
 ^ "Why is Python a dynamic language and also a strongly typed language - Python
Wiki". wiki.python.org. Retrieved 27 January2021.
 ^ "PEP 483 -- The Theory of Type Hints". Python.org.
 ^ "Download Python". Python.org. Retrieved 24 May 2021.
 ^ File extension .pyo was removed in Python 3.5. See PEP 0488
 ^ Holth, Moore (30 March 2014). "PEP 0441 -- Improving Python ZIP Application
Support". Retrieved 12 November 2015.

47