Fraud Detection in Signature Verification Using

Advanced Image Processing Techniques for Real-

Time Authentication
ABSTRACT
This research focuses on developing a feasible and efficient solution for verifying
handwritten signatures using advanced image processing techniques. The study is specifically
limited to signatures that involve static inputs and outputs, meaning that it does not take into
account dynamic elements such as writing speed or pressure. To identify the most suitable
classifier for accurate signature verification, multiple machine learning models were explored,
including the Multinomial Naïve Bayes Classifier (MNBC), Bernoulli Naïve Bayes Classifier
(BNBC), Logistic Regression Classifier (LRC), Stochastic Gradient Descent Classifier (SGDC),
and Random Forest Classifier (RFC). Each classifier was trained and evaluated using a publicly
available signature dataset to ensure consistency and reliability in performance measurement.

After rigorous testing, the Random Forest Classifier (RFC) demonstrated the highest
accuracy, achieving a score of approximately 0.99. This suggests that RFC is the most effective
model among those tested for distinguishing between genuine and forged signatures. On average,
the system has proven to be highly successful in verifying signature images with a significant
level of accuracy. The results of this study indicate that machine learning-based approaches,
particularly RFC, can provide a reliable method for signature authentication, which could be
beneficial in various real-time applications such as banking, legal document verification, and
identity authentication.
 TABLE OF CONTENTS

CHAPTER NO. TITLE PAGE NO.

ABSTRACT i
v
LIST OF FIGURES
LIST OF SYMBOLS vii
xi
LIST OF ABBREVIATIONS
LIST OF TABLES xii

1. CHAPTER 1 : INTRODUCTION
1.1 GENERAL
1.2 OBJECTIVE
1.3 EXISTING SYSTEM
1.3.1EXISTINGSYSTEM DISADVANTAGES
1.3.2 LITERATURE SURVEY
1.4 PROPOSED SYSTEM
1.4.1 PROPOSED SYSTEM ADVANTAGES
2. CHAPTER 2 :PROJECT DESCRIPTION
2.1 GENERAL
2.2 METHODOLOGIES
2.2.1 MODULES NAME
2.2.2 MODULES EXPLANATION
2.2.3 MODULE DIAGRAM
2.2.4GIVEN INPUTAND EXPECTED OUTPUT
2.3 TECHNIQUE OR ALGORITHM
3. CHAPTER 3 : REQUIREMENTS
3.1 GENERAL

3.2 HARDWARE REQUIREMENTS

3.3 SOFTWARE REQUIREMENTS

4. CHAPTER 4 : SYSTEM DESIGN

 4.1 GENERAL
4.1.1 ACTIVITY DIAGRAM
4.1.2 USE CASE DIAGRAM
4.1.3 DATA FLOW DIAGRAM
4.1.4SEQUENCE DIAGRAM
4.1.5 COLLABORATION DIAGRAM
4.1.6CLASS DIAGRAM
4.1.7 SYSTEM ARCHITECTURE
4.1.8 OBJECT DIAGRAM
4.1.9 STATE DIAGRAM
4.1.10 COMPONENT DIAGRAM
4.1.11 E-R DIAGRAM
4.2 DATABASE DESIGN (ALL LEVEL
5. CHAPTER 5 :SOFTWARE SPECIFICATION
5.1 PYTHON
5.2 HISTORY OF PYTHON
5.3 IMPARTANCE OF PYTHON
5.4 FEATURES OF PYTHON
5.5 LIBRARIES USED
CHAPTER 6 : IMPLEMENTATION
6. 6.1 GENERAL
6.2 IMPLEMENTATION
6.3 DATA BASE TABLE STRUCTURE
7. CHAPTER 7 : SNAPSHOTS
7.1 GENERAL
7.2 VARIOUS SNAPSHOTS
8. CHAPTER 8 : SOFTWARE TESTING
8.1 GENERAL
8.2 DEVELOPING METHODOLOGIES
8.3 TYPES OF TESTING
9. CHAPTER 9 :
 APPLICATIONS AND FUTURE ENHANCEMENT
9.1 GENERAL
9.2 APPLICATIONS
9.3 FUTURE ENHANCEMENTS
10. CHAPTER 10 :
10.1CONCLUSION
10.2 REFERENCES

LIST OF FIGURES
FIGURE NO NAME OF THE FIGURE PAGE NO.
2.3.2 Module Diagram

4.1 Use case Diagram

4.2 Class Diagram

4.3 Object Diagram

4.4 Component Diagram

4.5 Deployment Diagram

4.6 Sequence diagram

4.7 Collaboration diagram

4.8 State Diagram

4.9 Activity Diagram

4.10 Data flow diagram

4.11 E-R Diagram

4.12 Architecture Diagram

LIST OF SYSMBOLS
 NOTATION
S.NO NAME NOTATION DESCRIPTION

Class Name

1. Class Represents a collection of

similar entities grouped
+ public -attribute together.

-private -attribute

NAME Associations represents

Class A Class B
static relationships between
2. Association classes. Roles represents
the way the two classes see
Class A Class B each other.

3. Actor It aggregates several classes

into a single classes.

Class A Class A Interaction between the

Aggregation system and external
4. environment
Class B Class B
5.
Relation uses Used for additional process
(uses) communication.

Extends relationship is used

when one use case is similar
6. Relation extends to another use case but does
(extends) a bit more.

Communication between
7. Communication
various use cases.

State of the processs.

8. State State

9. Initial State Initial state of the object

10. Final state F inal state of the object

11. Control flow

Represents various control
flow between the states.

12. Decision box Represents decision making

process from a constraint
 Usescase Interact ion between the
13.
system and external
Usecase environment.

Represents physical
modules which are a
collection of components.
14. Component

Represents physical
15. Node modules which are a
collection of components.

A circle in DFD represents

a state or process which has
16. Data been triggered due to some
event or acion.
Process/State

Represents external entities

17. External entity
such as
keyboard,sensors,etc.

Represents communication
Transition
18. that occurs between
processes.

19. Object Lifeline Represents the vertical

dimensions that the object
communications.
 Represents the message
20. Message Message
exchanged.
 LIST OF ABBREVATION

S.NO ABBREVATION EXPANSION

1. ML Machine Learning

2. SVM Support Vector Machine

3. CNN Convolutional Neural Networks

4. ANN Artificial Neural Networks

5. AI Artificial Intelligence

6. DNN Deep Neural Networks

 CHAPTER 1
INTRODUCTION
1.1 GENERAL
The necessity for security is difficult often compounded by a tendency towards individual levels
of general apathy. Biometrics has received recognition from a vivid range of applications
available. Signature has been the most important and useful behavioral biometrics that is widely
accepted. The surge in the application of authentication and identification for personal
verification and security related application can be observed these years. The increasing studies
and development on signature verification has drawn the attention of researchers from different
fields of education. Each person has their own traits on the basis of which they can be
distinguished and hence authenticated. One can verify and identify the claimed person by two
mean of biometric system. Verification of signature means to verify whether the claimed person
is the actual genuine person whereas signature identification means person’s existing is there in
the given database or not. Biometric system relies on specific data about unique biological traits.
It thus verifies or identifies the claimed users. Biometric identifier are usually classified as
behavioral and physiological. Physiological characteristics refers to the form of body similar to
fingerprints, face recognition, DNA, etc while behavioral characteristics are related to the pattern
of behavior of a person including voice, gait etc. Automatic Off-line Signature authentication
and verification system occupy a very special position among the other automatic identification
methods. Handwritten signatures are persistent and are being used for identity verification. They
are used for getting permission in banks related works and transactions and thus have paved a
way for criminal deception. Hence automatic signature verification is required for access grant in
such areas. Depending upon ownership, signature can be genuine or insincere. Verifications are
done on the basis of the traits of users that can neither be changed nor be remodeled. Signature
verification is advantageous since it is biologically linked to a specific individual. Digitalized
system may exacerbate the problem of technological obsolescence. A signature is more difficult
to be forged then a fingerprint when a person is in unconscious state. Handwritten signature
results in complex process and features. It is used as a legal mean of verifying individual’s
identity by financial sectors and administrative.
1.2 OBJECTIVE

A lots of research had already been examined and shown their pivot contribution in the field of
biometric system mainly in off-line signature verification. Since off-line signature verification is
the most important biometric verification in today’s era, still it is very challenging area of
research. The main contributions of our work include: (1) Three kinds of pseudo-dynamic
features based on gray level were deliberately modeled and adapted to meet the special needs of
SV. The proposed features contain complementary information, so their fusion could achieve
better results. (2) We employed an ensemble learning method, RF, for writer-independent o²ine
SV and achieved competitive performance with state-of-the-art algorithms. (3) We empirically
analyzed two kinds of methods to generate negative samples for writer-independent SV and
found that different methods can create different decision boundaries and are suitable for
different forgery styles.
1.3 Existing System:

A signature verification system and the techniques used to solve this problem can be divided into
two classes online and Off-line. On-line approach uses an electronic tablet and a stylus
connected to a computer to extract information about a signature and takes dynamic information
like pressure, velocity, speed of writing etc. for verification purpose. Offline signature
verification involves less electronic control and uses signature images captured by scanner or
camera. An offline signature verification system uses features extracted from scanned signature
image. The features used for offline signature verification are much simpler. In this only the
pixel image needs to be evaluated. But, the off-line systems are difficult to design as many
desirable characteristics such as the order of strokes, the velocity and other dynamic information
are not available in the off-line case [4, 5]. The verification process has to wholly rely on the
features that can be extracted from the trace of the static signature images only.

Disadvantages:

 The duration of the network is unknown.

 Unexplained functioning.
LITERATURE SURVEY:
Title: A new effective approach for automatic off-line verification of signatures by using
pressure features.

Author: M. Ammar, Y. Yoshida and T. Fukumura

Year: 2009.

Description:

This chapter presents an off-line signature verification and forgery detection system based on
fuzzy modeling. The various handwritten signature characteristics and features are first studied
and encapsulated to devise a robust verification system. The verification of genuine signatures
and detection of forgeries is achieved via angle features extracted using a grid method. The
derived features are fuzzified by an exponential membership function, which is modified to
include two structural parameters. The structural parameters are devised to take account of
possible variations due to handwriting styles and to reflect other factors affecting the scripting of
a signature. The efficacy of the proposed system is tested on a large database of signatures
comprising more than 1,200 signature images obtained from 40 volunteers.
Title: a new signature verification technique based on a two stage neural network classifier

Author: H. Baltzakis and N. Papamarkos

Year: 2001.

Description:

This paper presents a new technique for off-line signature recognition and verification. The
proposed system is based on global, grid and texture features. For each one of these feature sets a
special two stage Perceptron OCON (one-class-one-network) classification structure has been
implemented. In the first stage, the classifier combines the decision results of the neural networks
and the Euclidean distance obtained using the three feature sets. The results of the first-stage
classifier feed a second-stage radial base function (RBF) neural network structure, which makes
the final decision. The entire system was extensively tested and yielded high recognition and
verification rates.
Title: Dynamic selection of generative–discriminative ensembles for off-line signature
verification.

Author: L. Batista, E. Granger and R. Sabourin

Year: 2012.

Description:

This chapter presents an off-line signature verification and forgery detection system based on
fuzzy modeling. The various handwritten signature characteristics and features are first studied
and encapsulated to devise a robust verification system. The verification of genuine signatures
and detection of forgeries is achieved via angle features extracted using a grid method. The
derived features are fuzzified by an exponential membership function, which is modified to
include two structural parameters. The structural parameters are devised to take account of
possible variations due to handwriting styles and to reflect other factors affecting the scripting of
a signature. The efficacy of the proposed system is tested on a large database of signatures
comprising more than 1,200 signature images obtained from 40 volunteers.
Title: Recovery of temporal information from static images of handwriting.

Author: P. Bugalho, and M. Viana-Baptista.

Year: 2001.

Description:

A taxonomy of local, regional, and global temporal clues that, along with a detailed examination
of the document, allow temporal properties to be recovered from the image is provided. It is
shown that this system will benefit from obtaining a comprehensive understanding of the
handwriting signal and that it requires a detailed analysis of stroke and sub-stroke properties. It is
suggested that this task requires breaking away from traditional thresholding and thinning
techniques, and a framework for such analysis is presented. It is shown how the temporal clues
can reliably be extracted from this framework and how many of the seemingly ambiguous
situations can be resolved by the derived clues and knowledge of the writing process.
Title: Towards automated transactions based on the offline handwritten signatures.

Author: G. S. Eskander, R. Sabourin and E. Granger.

Year: 2013.

Description:

Automating business transactions over the Internet relies on digital signatures, a replacement of
conventional handwritten signatures in paper-based processes. Although they guarantee data
integrity and authenticity, digital signatures are not as convenient to users as the manuscript
ones. In this paper, a methodology is proposed to produce digital signatures using off-line hand-
written signatures. This methodology facilitate the automation of business processes, where users
continually employ their handwritten signatures for authentication. Users are isolated from the
details related to the generation of digital signatures, yet benefit from enhanced security. First,
signature templates from a user are captured and employed to lock his private key in a fuzzy
vault. Then, when the user signs a document by hand, his handwritten signature image is
employed to unlock his private key. The unlocked key produces a digital signature that is
attached to the digitized document. The verification of the digital signature by a recipient implies
authenticity of the manuscript signature and integrity of the signed document. Experimental
results on the Brazilian off-line signature database (that includes various forgeries) confirms the
viability of the proposed approach. Private keys of 1024-bits were unlocked by signature images
with Average Error Rate of about 7.8%.
1.4 Proposed System
They were not able to adapt to the movement changes efficiently. The freezing of gait
proposed by freezing ratio (freezing frequencies divided by the power of gait frequencies of
horizontal shank acceleration). Reference [50] also proposed a similar implementation of
wearable sensors that collected datasets from healthy and osteoarthritis affected patients
walking on the ground surface. Gait parameters like joint kinematics, segment orientation, and
joint forces were noted. The paper reviewed researches on different body parts which affected
the gait of the patient. It showed fewer articles were involved in feedback than sensing. Hip,
Thigh, and Pelvis were the least noted body parts for both sensing and feedback gait
parameters.

1.4.2 ADVANTAGES: -

It is drastically improves the training and detection time.

It also improves Mean Average Precision (mAP).
 CHAPTER 2
PROJECT DESCRIPTION

2.1 METHODOLOGIES

2.1.1 MODULES NAME:

1. Signature Pre-Processing

2. Binarization

3. Complementation

4. Feature Extraction
1. Signature Pre-Processing

The preprocessing step is applied for already stored signature in database as well as the signature
is to be test. The purpose of this step is to make the signature normalized in one form and
improve the quality of image which is suitable for feature extraction. The preprocessing stages
includes.

2. Binarization
Binarization of gray scale signature is obtained by adaptive thresholding value. It begin with a
threshold value for different signature which is being calculated by the method of thresholding.
For each signature pixel element it computes associate intensity gradient by selecting a
maximum of difference of left and right signature pixel intensity and upper and lower signature
pixel intensity respectively to calculate the corresponding threshold. Finally, thresholding
method is exploited for Binarization. During this technique intensity of every signature pixel
intensity is compared with the threshold value. The signature pixel intensity is set to 1 for the
pixel intensity value higher than the threshold while for lower value it is set to 0.

3. Complementation
Complement of a binarized signature means converting the zeros into ones and ones into zeros.
Complementation of signature image results in better visibility of great difference of gray levels.
It helps us to identify the fine detail in precise manner for signature image which helps to
correctly calculate the features to classify about signature between genuine or forged.
Complemented signature image is having more clarity for further operation since the lighter
pixel in signature become dark and the dark area become lighter.
4. Feature Extraction
It is quite difficult that which feature is to be choose for further verification of signature. Feature
of signature image is thus been extracted and can be used as a reference points for further
verification of signature. In our work, feature as a vector of seven entities which include entropy,
number of closed loop and so on are used to precisely authenticate and verify the test signature.
These features that has been depicted in Table 1.
 CHAPTER 3

REQUIREMENTS ENGINEERING

3.1 GENERAL

We can see from the results that on each database, the error rates are very low due to the
discriminatory power of features and the regression capabilities of classifiers. Comparing the
highest accuracies (corresponding to the lowest error rates) to those of previous works, our
results are very competitive.
3.2 HARDWARE REQUIREMENTS

The hardware requirements may serve as the basis for a contract for the
implementation of the system and should therefore be a complete and consistent
specification of the whole system. They are used by software engineers as the
starting point for the system design. It should what the system do and not how it
should be implemented.

 PROCESSOR : DUAL CORE 2 DUOS.

 RAM : 4GB DD RAM
 HARD DISK : 250 GB
3.3 SOFTWARE REQUIREMENTS

The software requirements document is the specification of the system. It should include both a
definition and a specification of requirements. It is a set of what the system should do rather than
how it should do it. The software requirements provide a basis for creating the software
requirements specification. It is useful in estimating cost, planning team activities, performing
tasks and tracking the teams and tracking the team’s progress throughout the development
activity.

 Operating System : Windows 7/8/10

 Platform : Spyder3

 Programming Language : Python

 Front End : Spyder3

3.4 FUNCTIONAL REQUIREMENTS

A functional requirement defines a function of a software-system or its component. A function is

described as a set of inputs, the behavior, Firstly, the system is the first that achieves the standard
notion of semantic security for data confidentiality in attribute-based deduplication systems by
resorting to the hybrid cloud architecture.
3.5 NON-FUNCTIONAL REQUIREMENTS

EFFICIENCY

Our multi-modal event tracking and evolution framework is suitable for multimedia documents
from various social media platforms, which can not only effectively capture their multi-modal
topics, but also obtain the evolutionary trends of social events and generate effective event
summary details over time. Our proposed mmETM model can exploit the multi-modal property
of social event, which can effectively model social media documents including long text with
related images and learn the correlations between textual and visual modalities to separate the
visual-representative topics and non-visual-representative topics.
 CHAPTER 4

DESIGN ENGINEERING

4.1 GENERAL

Design Engineering deals with the various UML [Unified Modelling language] diagrams
for the implementation of project. Design is a meaningful engineering representation of a thing
that is to be built. Software design is a process through which the requirements are translated into
representation of the software. Design is the place where quality is rendered in software
engineering.
4.2 UML DIAGRAMS

4.2.1 USE CASE DIAGRAM

Read Images

Preprocessing

Random Forest
Dataset Input User Input

Predictions

Signature Real/Fraud detection

EXPLANATION:
The main purpose of a use case diagram is to show what system functions are performed for
which actor. Roles of the actors in the system can be depicted. The above diagram consists of
user as actor. Each will play a certain role to achieve the concept.
4.2.2 CLASS DIAGRAM

Pre-processing- Read Image

User Login
Reshaping image for Reading image
login pattern
array conversion of image
Dataset Input
Imread()
array()
Java Script()
expand_dims()

Random Forest
User Input Predictions
train & extract features
user Signature image input Predict values From train data
classification()
inputPath() predict()
sklearn()

Signature Real/Fraud detection

display Signature Real/Fraud

HTML()
display()

EXPLANATION

In this class diagram represents how the classes with attributes and methods are linked together
to perform the verification with security. From the above diagram shown the various classes
involved in our project.
4.2.3 OBJECT DIAGRAM

Dataset Input Read Images Open & Load Model

Predictions Random Forest Pre-processing

User Input

Signature Real/Fraud detection

EXPLANATION:

In the above digram tells about the flow of objects between the classes. It is a diagram that shows
a complete or partial view of the structure of a modeled system. In this object diagram represents
how the classes with attributes and methods are linked together to perform the verification with
security.
4.2.8 STATE DIAGRAM

Dataset Input

Read Image

Pre-processing

Random Forest

User Input

Predictions

Signature Real/Fraud detection

EXPLANATION:

State diagram are a loosely defined diagram to show workflows of stepwise activities and
actions, with support for choice, iteration and concurrency. State diagrams require that the
system described is composed of a finite number of states; sometimes, this is indeed the case,
while at other times this is a reasonable abstraction. Many forms of state diagrams exist, which
differ slightly and have different semantics.
4.2.9 ACTIVITY DIAGRAM

User Login

Read Image

Pre-processings

Random Forest

User Input

Predictions

Signature Real/Fraud detection

EXPLANATION:
Activity diagrams are graphical representations of workflows of stepwise activities and
actions with support for choice, iteration and concurrency. In the Unified Modeling Language,
activity diagrams can be used to describe the business and operational step-by-step workflows of
components in a system. An activity diagram shows the overall flow of control.
4.2.6 SEQUENCE DIAGRAM

Dataset Read Pre-processing Random Forest User Signature Real/Fraud

Input Images Input detection

Define path & select Signatures dataset

used to read Signatures dataset

used to convert data into array format for expanding

classification train & extract features

user Signature image input

predict user input from train

display Signature Real/Fraud

EXPLANATION:

A sequence diagram in Unified Modeling Language (UML) is a kind of interaction

diagram that shows how processes operate with one another and in what order. It is a construct of
a Message Sequence Chart. A sequence diagram shows object interactions arranged in time
sequence. It depicts the objects and classes involved in the scenario and the sequence of
messages exchanged between the objects needed to carry out the functionality of the scenario.
4.2.7 COLLABORATION DIAGRAM

0: user services depend on user requirement

0: collect User data
Dataset Input Read Pre-processing
Images

3: used to convert data into array format for

expanding dimensions
0: display Lane output for our users inputs
Random
Forest
4: classification train & extract features

0: display data to admin

5: user Signature image input

Signature Real/Fraud
User Input
detection

6: predict user input from train model

EXPLANATION:
A collaboration diagram, also called a communication diagram or interaction diagram, is
an illustration of the relationships and interactions among software objects in the Unified
Modeling Language (UML). The concept is more than a decade old although it has been refined
as modeling paradigms have evolved.
4.2.4 COMPONENT DIAGRAM

Dataset Read Image

Input

Pre-processing
User Login

Signature Real/Fraud Predictions Random Forest

detection

EXPLANATION

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. User gives main query and it converted into sub queries
and sends through data dissemination to data aggregators. Results are to be showed to user by
data aggregators. All boxes are components and arrow indicates dependencies.
4.2.5 DEPLOYMENT DIAGRAM

Collect Dataset Open & Load Model

User Input Random Forest Pre-processing

Signature Real/Fraud
Predictions
detection

EXPLANATION:

Deployment Diagram is a type of diagram that specifies the physical hardware on which the
software system will execute. It also determines how the software is deployed on the underlying
hardware. It maps software pieces of a system to the device that are going to execute it.
Data Flow Diagram
Level-0:

User
Dataset input

Read Images & Load models

Pre-Processing
Level-1

Splitting

Random Forest

User Input

System Prediction

Signature Real/Fraud detection

System Architecture

Fig 4.12: System Architecture

 CHAPTER 5

DEVELOPMENT TOOLS

5.1 Python

Python is a high-level, interpreted, interactive and object-oriented scripting language. Python is

designed to be highly readable. It uses English keywords frequently where as other languages
use punctuation, and it has fewer syntactical constructions than other languages.

5.2 History of Python

Python was developed by Guido van Rossum in the late eighties and early nineties at the
National Research Institute for Mathematics and Computer Science in the Netherlands.

Python is derived from many other languages, including ABC, Modula-3, C, C++, Algol-68,
SmallTalk, and Unix shell and other scripting languages.

Python is copyrighted. Like Perl, Python source code is now available under the GNU General
Public License (GPL).

Python is now maintained by a core development team at the institute, although Guido van
Rossum still holds a vital role in directing its progress.

5.3 Importance of Python

 Python is Interpreted − Python is processed at runtime by the interpreter. You do not
need to compile your program before executing it. This is similar to PERL and PHP.
 Python is Interactive − You can actually sit at a Python prompt and interact with the
interpreter directly to write your programs.
 Python is Object-Oriented − Python supports Object-Oriented style or technique of
programming that encapsulates code within objects.
 Python is a Beginner's Language − Python is a great language for the beginner-level
programmers and supports the development of a wide range of applications from simple
text processing to WWW browsers to games.
5.4 Features of Python

 Easy-to-learn − Python has few keywords, simple structure, and a clearly defined
syntax. This allows the student to pick up the language quickly.
 Easy-to-read − Python code is more clearly defined and visible to the eyes.
 Easy-to-maintain − Python's source code is fairly easy-to-maintain.
 A broad standard library − Python's bulk of the library is very portable and cross-
platform compatible on UNIX, Windows, and Macintosh.
 Interactive Mode − Python has support for an interactive mode which allows interactive
testing and debugging of snippets of code.
 Portable − Python can run on a wide variety of hardware platforms and has the same
interface on all platforms.
 Extendable − You can add low-level modules to the Python interpreter. These modules
enable programmers to add to or customize their tools to be more efficient.
 Databases − Python provides interfaces to all major commercial databases.
 GUI Programming − Python supports GUI applications that can be created and ported
to many system calls, libraries and windows systems, such as Windows MFC,
Macintosh, and the X Window system of Unix.
 Scalable − Python provides a better structure and support for large programs than shell
scripting.

Apart from the above-mentioned features, Python has a big list of good features, few are listed
below −

 It supports functional and structured programming methods as well as OOP.

 It can be used as a scripting language or can be compiled to byte-code for building large
applications.
  It provides very high-level dynamic data types and supports dynamic type checking.
 IT supports automatic garbage collection.
 It can be easily integrated with C, C++, COM, ActiveX, CORBA, and Java.

5.5 Libraries used in python

 numpy - mainly useful for its N-dimensional array objects.

 pandas - Python data analysis library, including structures such as dataframes.
 matplotlib - 2D plotting library producing publication quality figures.
 scikit-learn - the machine learning algorithms used for data analysis and data mining
tasks.

Figure : NumPy, Pandas, Matplotlib, Scikit-learn

CHAPTER 6

IMPLEMENTATION

6.1 GENERAL

Coding:
# Importing the libraries

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

from sklearn.model_selection import GridSearchCV

from sklearn.tree import DecisionTreeClassifier

from sklearn.metrics import accuracy_score, roc_auc_score, roc_curve

# Importing the dataset

dataset = pd.read_csv('../Dataset/diabetes.csv')

X = dataset.iloc[:, :-1].values

y = dataset.iloc[:, 8].values

# Splitting the dataset into the Training set and Test set

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 42)

# Feature Scaling

from sklearn.preprocessing import StandardScaler

sc = StandardScaler()

X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

# Parameter evaluation

treeclf = DecisionTreeClassifier(random_state=42)

parameters = {'max_depth': [6, 7, 8, 9],

'min_samples_split': [2, 3, 4, 5],

'max_features': [1, 2, 3, 4]

gridsearch=GridSearchCV(treeclf, parameters, cv=100, scoring='roc_auc')

gridsearch.fit(X,y)

print(gridsearch.best_params_)

print(gridsearch.best_score_)

# Adjusting development threshold

tree = DecisionTreeClassifier(max_depth = 6, max_features = 4,

min_samples_split = 5,

random_state=42)

X_train,X_test,y_train,y_test = train_test_split(X, y, random_state=42)

tree.fit(X_train, y_train)

print("Accuracy on training set: {:.3f}".format(tree.score(X_train, y_train)))

print("Accuracy on test set: {:.3f}".format(tree.score(X_test, y_test)))

# Predicting the Test set results

y_pred = tree.predict(X_test)

# Making the Confusion Matrix

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)

print('TP - True Negative {}'.format(cm[0,0]))

print('FP - False Positive {}'.format(cm[0,1]))

print('FN - False Negative {}'.format(cm[1,0]))

print('TP - True Positive {}'.format(cm[1,1]))

print('Accuracy Rate: {}'.format(np.divide(np.sum([cm[0,0],cm[1,1]]),np.sum(cm))))

print('Misclassification Rate: {}'.format(np.divide(np.sum([cm[0,1],cm[1,0]]),np.sum(cm))))

round(roc_auc_score(y_test,y_pred),5)

# Importing the libraries

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score

from sklearn.model_selection import GridSearchCV

from sklearn.metrics import accuracy_score, roc_auc_score, roc_curve

from sklearn.neighbors import KNeighborsClassifier

# Importing the dataset

dataset = pd.read_csv('../Dataset/diabetes.csv')

X = dataset.iloc[:, :-1].values

y = dataset.iloc[:, 8].values

# Splitting the dataset into the Training set and Test set

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25,

random_state = 42)

# Feature Scaling

from sklearn.preprocessing import StandardScaler

sc = StandardScaler()

X_train = sc.fit_transform(X_train)

X_test = sc.transform(X_test)

# Parameter evaluation

knnclf = KNeighborsClassifier()
parameters={'n_neighbors': range(1, 20)}

gridsearch=GridSearchCV(knnclf, parameters, cv=100, scoring='roc_auc')

gridsearch.fit(X, y)

print(gridsearch.best_params_)

print(gridsearch.best_score_)

# Fitting K-NN to the Training set

knnClassifier = KNeighborsClassifier(n_neighbors = 18)

knnClassifier.fit(X_train, y_train)

print('Accuracy of K-NN classifier on training set: {:.2f}'.format(knnClassifier.score(X_train,

y_train)))

print('Accuracy of K-NN classifier on test set: {:.2f}'.format(knnClassifier.score(X_test, y_test)))

# Predicting the Test set results

y_pred = knnClassifier.predict(X_test)

# Making the Confusion Matrix

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)

print('TP - True Negative {}'.format(cm[0,0]))

print('FP - False Positive {}'.format(cm[0,1]))

print('FN - False Negative {}'.format(cm[1,0]))

print('TP - True Positive {}'.format(cm[1,1]))

print('Accuracy Rate: {}'.format(np.divide(np.sum([cm[0,0],cm[1,1]]),np.sum(cm))))

print('Misclassification Rate: {}'.format(np.divide(np.sum([cm[0,1],cm[1,0]]),np.sum(cm))))

round(roc_auc_score(y_test,y_pred),5)

# Importing the libraries

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split, cross_val_score

from sklearn.model_selection import GridSearchCV

from sklearn.metrics import accuracy_score, roc_auc_score, roc_curve

from sklearn.svm import SVC

import matplotlib.pyplot as plt

from sklearn.metrics import classification_report

# Importing the dataset

dataset = pd.read_csv('../Dataset/diabetes.csv')

X = dataset.iloc[:, :-1].values

y = dataset.iloc[:, 8].values
# Splitting the dataset into the Training set and Test set

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25,

random_state = 42)

# Feature Scaling

from sklearn.preprocessing import StandardScaler

sc = StandardScaler()

X_train = sc.fit_transform(X_train)

X_test = sc.transform(X_test)

#svm with grid search

svm = SVC(random_state = 42)

parameters = {'kernel':('linear', 'rbf'), 'C':(1,0.25,0.5,0.75),

'gamma': (1,2,3,'auto'),'decision_function_shape':('ovo','ovr'),

'shrinking':(True,False)}

scores = ['precision', 'recall']

for score in scores:

print("# Tuning hyper-parameters for %s" % score)

print()
svm = GridSearchCV(SVC(), parameters, cv=5,

scoring='%s_macro' % score)

svm.fit(X_train, y_train)

print("Best parameters set found on development set:")

print()

print(svm.best_params_)

print()

print("Grid scores on development set:")

print()

means = svm.cv_results_['mean_test_score']

stds = svm.cv_results_['std_test_score']

for mean, std, params in zip(means, stds, svm.cv_results_['params']):

print("%0.3f (+/-%0.03f) for %r"

% (mean, std * 2, params))

print()

print("Detailed classification report:")

print()

print("The model is trained on the full development set.")

print("The scores are computed on the full evaluation set.")

 print()

y_true, y_pred = y_test, svm.predict(X_test)

print(classification_report(y_true, y_pred))

print()

svm_model = SVC(kernel='rbf', C=100, gamma = 0.0001, random_state=42)

svm_model.fit(X_train, y_train)

spred = svm_model.predict(X_test)

print ('Accuracy with SVM {0}'.format(accuracy_score(spred, y_test) * 100))

# Making the Confusion Matrix

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)

print('TP - True Negative {}'.format(cm[0,0]))

print('FP - False Positive {}'.format(cm[0,1]))

print('FN - False Negative {}'.format(cm[1,0]))

print('TP - True Positive {}'.format(cm[1,1]))

print('Accuracy Rate: {}'.format(np.divide(np.sum([cm[0,0],cm[1,1]]),np.sum(cm))))

print('Misclassification Rate: {}'.format(np.divide(np.sum([cm[0,1],cm[1,0]]),np.sum(cm))))

svm.fit(X_train, y_train)

round(roc_auc_score(y_test,y_pred),5)
 CHAPTER 7

SNAPSHOTS

General:
 This project is implements like application using python and the Server process is maintained
using the SOCKET & SERVERSOCKET and the Design part is played by Cascading Style
Sheet.

SNAPSHOTS

CHAPTER 8
SOFTWARE TESTING
8.1 GENERAL
The purpose of testing is to discover errors. Testing is the process of trying to discover
every conceivable fault or weakness in a work product. It provides a way to check the
functionality of components, sub-assemblies, assemblies and/or a finished product It is the
process of exercising software with the intent of ensuring that the Software system meets its
requirements and user expectations and does not fail in an unacceptable manner. There are
various types of test. Each test type addresses a specific testing requirement.

8.2 DEVELOPING METHODOLOGIES

The test process is initiated by developing a comprehensive plan to test the general
functionality and special features on a variety of platform combinations. Strict quality control
procedures are used. The process verifies that the application meets the requirements specified in
the system requirements document and is bug free. The following are the considerations used to
develop the framework from developing the testing methodologies.

8.3Types of Tests

8.3.1 Unit testing

Unit testing involves the design of test cases that validate that the internal program logic
is functioning properly, and that program input produce valid outputs. All decision branches and
internal code flow should be validated. It is the testing of individual software units of the
application .it is done after the completion of an individual unit before integration. This is a
structural testing, that relies on knowledge of its construction and is invasive. Unit tests perform
basic tests at component level and test a specific business process, application, and/or system
configuration. Unit tests ensure that each unique path of a business process performs accurately
to the documented specifications and contains clearly defined inputs and expected results.

8.3.2 Functional test

Functional tests provide systematic demonstrations that functions tested are available as
specified by the business and technical requirements, system documentation, and user manuals.
Functional testing is centered on the following items:
Valid Input : identified classes of valid input must be accepted.
Invalid Input : identified classes of invalid input must be rejected.
Functions : identified functions must be exercised.
Output : identified classes of application outputs must be exercised.
Systems/Procedures: interfacing systems or procedures must be invoked.

8.3.3 System Test

System testing ensures that the entire integrated software system meets requirements. It
tests a configuration to ensure known and predictable results. An example of system testing is the
configuration oriented system integration test. System testing is based on process descriptions
and flows, emphasizing pre-driven process links and integration points.

8.3.4 Performance Test

The Performance test ensures that the output be produced within the time limits,and the
time taken by the system for compiling, giving response to the users and request being send to
the system for to retrieve the results.

8.3.5 Integration Testing

Software integration testing is the incremental integration testing of two or more
integrated software components on a single platform to produce failures caused by interface
defects.
The task of the integration test is to check that components or software applications, e.g.
components in a software system or – one step up – software applications at the company level –
interact without error.

8.3.6 Acceptance Testing

User Acceptance Testing is a critical phase of any project and requires significant
participation by the end user. It also ensures that the system meets the functional requirements.
Acceptance testing for Data Synchronization:
 The Acknowledgements will be received by the Sender Node after the Packets are
received by the Destination Node
 The Route add operation is done only when there is a Route request in need
 The Status of Nodes information is done automatically in the Cache Updation process

8.2.7 Build the test plan

Any project can be divided into units that can be further performed for detailed
processing. Then a testing strategy for each of this unit is carried out. Unit testing helps to
identity the possible bugs in the individual component, so the component that has bugs can be
identified and can be rectified from errors.

CHAPTER 9

FUTURE ENHANCEMENT
In the future, we will incorporate some additional ideas such as selecting an elective
preprocessing method, using structural features and utilizing advanced feature selection and
classi¯ers.13–15, 24–26, 31, 51, 52 In addition, it is a promising research topic to investigate
how to use fewer reference signatures for verification and still get a reasonable result.

CHAPTER 10

CONCLUSION & REFERENCE

10.1 CONCLUSION

We present an automatic o²ine SV system using local features in writer-independent mode.

Pseudo-dynamic features based on gray level such as GLBP, SGLCM and SHOG are extracted.
SVM, Ad boost, and RF classier are tested and our study ends that RF can achieve better results.
The proposed method could get 7.42%, 9.05%, and 0.08% AER on GPDS-253, CSD, and
CEDAR datasets, respectively. It shows that our method could get competitive results than state-
of-the-art methods on these datasets. Experiments on the SigComp2011 dataset further
demonstrate the robustness and exigency of our method. In the future, we will incorporate some
additional ideas such as selecting an elective preprocessing method, using structural features and
utilizing advanced feature selection and classi¯ers.13–15, 24–26, 31, 51, 52 In addition, it is a
promising research topic to investigate how to use fewer reference signatures for verification and
still get a reasonable result.

REFERENCES
1. M. Ammar, Y. Yoshida and T. Fukumura, A new e®ective approach for automatic o®-line
veri¯cation of signatures by using pressure features, in Int. Conf. Pattern Recognition, IEEE
Computer Society Press (Washington DC, USA, 1986), pp. 566–569.

2. H. Baltzakis and N. Papamarkos, A new signature veri¯cation technique based on a twostage

neural network classi¯er, Eng. Appl. Artif. Intell. 14(1) (2001) 95–103.

3. L. Batista, E. Granger and R. Sabourin, Dynamic selection of generative–discriminative

ensembles for o®-line signature veri¯cation, Pattern Recognit. 45(4) (2012) 1326–1340.

4. N. Dalal and B. Triggs, Histograms of oriented gradients for human detection, IEEE Comput.
Soc. Conf. Comput. Vision Pattern Recognit. 1 (2005) 886–893.

5. D. Doermann and A. Rosenfeld, Recovery of temporal information from static images of

handwriting, Int. J. Comput. Vision 15(1–2) (2001) 143–164.

6. G. S. Eskander, R. Sabourin and E. Granger, Dissimilarity representation for handwritten

signature veri¯cation, in 2nd Int. Workshop on Automated Forensic Handwriting Analysis
(AFHA) (2013), pp. 26–30.

7. G. S. Eskander, R. Sabourin and E. Granger, A dissimilarity-based approach for biometric

fuzzy vaults-application to handwritten signature images, Int. Workshop on Emerging Aspects in
Handwritten Signature Processing (ICIAP 2013, Springer Verlag, Berlin, Germany), pp. 95–102.
8. G. S. Eskander, R. Sabourin and E. Granger, Towards automated transactions based on the
o²ine handwritten signatures, in 9th Int. Conf. Machine Learning and Data Mining (MLDM),
(Springer Verlag, Berlin, Germany, 2013), pp. 141–150.

9. G. S. Eskander, R. Sabourin and E. Granger, On the dissimilarity representation and prototype

selection for signature-based bio-cryptographic systems, in 2nd Intel Workshop on Similarity-
Based Pattern Analysis and Recognition (SIMBAD) (Springer Verlag, Berlin, Germany, 2013),
pp. 265–280.

10. G. S. Eskander, R. Sabourin and E. Granger, Improving signature-based biometric

cryptosystems using cascaded signature veri¯cation-fuzzy vault (SV-FV) approach, in The 14th
Int. Conf. Frontiers in Handwriting Recognition (ICFHR) (Institute of Electrical and Electronics
Engineers Inc., New Jersey, USA, 2014), pp. 187–192.

11. G. S. Eskander, R. Sabourin and E. Granger, O²ine signature-based fuzzy vault (OSFV):
Review and new results, arXiv:1408.3985.

12. M. A. Ferrer, F. Vargas, C. M. Travieso and J. B. Alonso, Signature veri¯cation using local
directional pattern (LDP), in Int. Carnahan.Conf. on Security Technology (ICCST), (Institute of
Electrical and Electronics Engineers Inc., New Jersey, USA, 2010), pp. 336–340.

13. Z. Fu, X. Sun, Q. Liu, L. Zhou and J. Shu, Achieving e±cient cloud search services:
Multikeyword ranked search over encrypted cloud data supporting parallel computing, IEICE
Trans. Commun. E98-B(1) (2015) 190–200.

14. B. Gu, V. S. Sheng, K. Y. Tay, W. Romano and S. Li, Incremental support vector learning
for ordinal regression, IEEE Trans. Neural Netws. Learn. Syst. 26(7) (2015) 1403–1416.

15. B. Gu, V. S. Sheng, Z. Wang, D. Ho, S. Osman and S. Li, Incremental learning for -support
vector regression, Neural Netws. 67 (2015) 140–150.

16. Y. Guerbai, Y. Chibani and B. Hadjadji, The e®ective use of the one-class SVM classi¯er for
handwritten signature veri¯cation based on writer-independent parameters, Pattern Recognit
48(1) (2015) 103–113.

17. J. Guo, D. Doermann and A. Rosenfeld, Forgery detection by local correspondence, Int. J.
Pattern Recognit. Artif. Intell. 15(4) (2001) 579–641.

18. A. Hamadene, Y. Chibani and H. Nemmour, O®-line handwritten signature veri¯cation

using contourlet transform and co-occurrence matrix, in Int. Conf. on Frontiers in Handwriting
Recognition (ICFHR), (IEEE Computer Society, Washington, USA, 2012), pp. 343–347.

19. J. Hu and Y. Chen, Fusion of features and classi¯ers for o®-line handwritten signature
veri¯cation, in Asian Conf. Pattern Recognition (IEEE Computer Society, Washington, USA,
2011), pp. 174–178.
20. J. Hu and Y. Chen, O²ine signature veri¯cation using real adaboost classi¯er combination of
pseudo-dynamic features, in Int. Conf. Document Analysis and Recognition (ICDAR) (IEEE
Computer Society, Washington, USA, 2013), pp. 1345–1349.

21. K. Huang and H. Yan, O®-line signature veri¯cation using structural feature correspondence,
Pattern Recognit. 35(11) (2002) 2467–2477.

22. E. J. R. Justino, A. E. Yacoubi, F. Bortolozzi and R. Sabourin, An o®-line signature

veri¯cation system using HMM and graphometric features, in Int. Workshop on Document
Analysis Systems (DAS) (IAPR, NY, USA, 2000), pp. 211–222.

23. R. Kumar, J. D. Sharma and B. Chanda, Writer-independent o®-line signature veri¯- cation
using surroundedness feature, Pattern Recognit. Lett. 33(3) (2012) 301–308.

24. Z. Lai, W. Wong, Y. Xu, C. Zhao and M. Sun, Sparse alignment for robust tensor learning,
IEEE Trans. Neural Netws. Learn. Syst. 25(10) (2014) 1779–1792.

25. Z. Lai, W. Wong, Y. Xu, J. Yang and D. Zhang, Approximate orthogonal sparse embedding
for dimensionality reduction, IEEE Trans. Neural Netws. Learn. Syst. 27(4) (2016) 723–735.

26. Z. Lai, Y. Xu, Q. Chen, J. Yang and D. Zhang, Multilinear sparse principal component
analysis, IEEE Trans. Neural Netws. Learn. Syst. 25(10) (2014) 1942–1950.

27. F. Leclerc and R. Plamondon, Automatic signature veri¯cation: the state of the art — 1989–
1993, Int. J. Pattern Recogn. Artif. Intell. 8(3) (1994) 643–660.

28. S. Lee and J. C. Pan, O²ine tracing and representation of signatures, IEEE Trans. System
Man Cybern. 22(4) (1992) 755–771.

29. A. Liaw and M. Wiener, Classi¯cation and regression by random forest, R news 2(3) (2002)
18–22.

30. M. Liwicki, M. I. Malik, C. E. van den Heuvel, X. Chen, C. Berger, R. Stoel, M.

Blumenstein and B. Found, Signature veri¯cation competition for online and o²ine skilled
forgeries (SigComp2011), in Int. Conf. Document Analysis and Recognition (ICDAR) (2011),
pp. 1480–1484.
31. Y. Lu, Z. Lai, Y. Xu, X. Li, D. Zhang and C. Yuan, Low rank preserving projections, IEEE
Trans. Cybern. 46(8) (2016) 1900–1913.

32. H. Lv, W. Wang, C. Wang and Q. Zhuo, O®-line Chinese signature veri¯cation based on
support vector machines, Pattern Recognit. Lett. 26(15) (2005) 2390–2399.

33. M. I. Malik, M. Liwicki, L. Alewijnse, W. Ohyama, M. Blumenstein and B. Found, ICDAR

2013 competitions on signature veri¯cation and writer identi¯cation for on-and o²ine skilled
forgeries (SigWiComp), in Document Analysis and Recognition (ICDAR), (IEEE Computer
Society, Washington, USA, 2013) pp. 1477–1483.

34. A. Mitra, P. Kumar and C. Ardil, Automatic authenti¯cation of handwritten documents via
low density pixel measurements, Int. J. Comput. Intell. 2(4) (2005) 219–223.

35. V. Nguyen, M. Blumenstein and G. Leedham, Global features for the o®-line signature
veri¯cation problem, in Int. Conf. Document Analysis and Recognition, (IEEE Computer
Society, Washington, USA, 2009), pp. 1300–1304.

36. T. Ojala, M. Pietikäinen and T. Mäenpää, Multiresolution gray-scale and rotation invariant
texture classi¯cation with local binary patterns, IEEE Trans. Pattern Anal. Mach. Intell. 24(7)
(2002) 971–987.

37. L. Oliveira, E. Justino, C. Freitas and R. Sabourin, The graphology applied to signature
veri¯cation, in Int. Conf. of Graphonomics Society, (Institute of Physics Publishing, Bristol, UK,
2005), pp. 286–290.

38. L. S. Oliveira, E. Justino, R. Sabourin, O®-line signature veri¯cation using writer-

independent approach, in Int. Joint Conf. on Neural Networks, (Institute of Electrical and
Electronics Engineers Inc., New Jersey, USA, 2007), pp. 2539–2544.

39. M. Parodi and C. G. Juan, Online signature veri¯cation: Improving performance through pre-
classi¯cation based on global features, New Trends in Image Analysis and Processing (ICIAP)
(Springer Verlag, Berlin, Germany, 2013), pp. 69–76.

40. G. Pirlo, D. Impedovo and M. Fairhurst (eds.), Advances in Digital Handwritten Signature
Processing: A Human Artifact for E-Society (World Scienti¯c, 2014).
 41. R. Plamondon and S. N. Srihari, Online and o®-line handwriting recognition: A
comprehensive survey, IEEE Trans. Pattern Anal. Mach. Intell. 22(1) (2000) 63–84.

42. A. C. Ramachandra, S. R. Jyothi, K. B. Raja, K. R. Venugopla and L. M. Patnaik, Robust

o²ine signature veri¯cation based on global features, in Int. Advance Computing Conf (IACC),
(Inst. of Elec. and Elec. Eng. Computer Society, Washington, USA, 2009), pp. 1173–1178.

43. G. Ridgeway, The state of boosting, Comput. Sci. Statist. 31 (1999) 172–181.

44. D. Rivard, É. Granger and R. Sabourin, Multi-feature extraction and selection in

writerindependent o²ine signature veri¯cation, Int. J. Document Anal. Recognit. 16(1) (2013)
83–103.

45. I. Siddiqi and N. Vincent, A set of chain code based features for writer recognition, in Int.
Conf. on Document Analysis and Recognition, (IEEE Computer Society, Washington, USA
2009), pp. 981–985.

46. S. N. Srihari, C. Huang, H. Srinivasan and V. Shah, Biometric and forensic aspects of digital
document processing, Digital Document Processing (Springer London, 2007), pp. 379–405.

47. S. N. Srihari, A. Xu and M. K. Kalera, Learning strategies and classi¯cation methods for o®-
line signature veri¯cation, in 9th Int. Workshop on Frontiers in Handwriting Recognition (IEEE
Computer Society, Washington, USA, 2004), pp. 161–166.

48. J. F. Vargas, M. A. Ferrer, C. M. Travieso and J. B. Alonson, O®-line handwritten signature

GPDS-960 corpus, in 9th Int. Conf. Document Analysis and Recognition (ICDAR) 2 (Inst. of
Elec. and Elec. Eng. Computer Society, Washington, USA, 2007), pp. 764–768.

49. F. J. Vargas, M. A. Ferrer, C. M. Travieso and J. B. Alonso, O®-line signature veri¯cation

based on high pressure polar distribution, in Int. Conf. on Frontiers in Handwriting Recognition
(Concordia University, Montreal, Quebec, Canada, 2008), pp. 373–378.

50. F. J. Vargas, M. A. Ferrer, C. M. Travieso and J. B. Alonso, O®-line signature veri¯cation

based on gray level information using texture features, Pattern Recognition 44(2) (2011) 375–
385. 51. X. Wen, L. Shao, Y. Xue and W. Fang, A rapid learning algorithm for vehicle classi¯-
cation, Inform. Sci. 295(1) (2015) 395–406.
 52. W. Wong, Z. Lai, Y. Xu and J. Wen, Joint tensor feature analysis for visual object
recognition, IEEE Trans. Cybern. 45(11) (2015) 2425–2436.

53. B. Xu, D. Lin, L. Wang, H. Chao, W. Li and Q. Liao, Performance comparison of local
directional pattern to local binary pattern in o®-line signature veri¯cation system, Int. Cong.
Image Signal Process. (CISP) (Institute of Electrical and Electronics Engineers Inc., NY, USA,
2014) 308–312.

54. M. B. Yilmaz and B. Yanikoglu, Score level fusion of classi¯ers in o®-line signature
veri¯cation, Inform. Fusion 32 (2016) 109–119.

55. M. B. Yilmaz, B. Yanikoglu, C. Tirkaz and A. Kholmatov, O²ine signature veri¯cation using
classi¯er combination of HOG and LBP features, in Int. Joint Conf. on Biometrics (IJCB), (IEEE
Computer Society, Washington, USA, 2011), pp. 1–7.