human signature
TRANSCRIPT
Rajagiri School of Engineering & Technology, Kakkanad
1. INTRODUCTION
Human signature is one of the best biometric feature that can be used for implementing
security systems. The signature of each person is unique in nature and can be used as a
strong biometric feature to support security.
Signature verification is an art: Whereas we may bring objective measures to bear on the
problem, in the final analysis, the problem remains subjective. This art is both well
studied and well documented as it applies to the verification by humans of signatures
whose only records are visual - that is, as it applies to signatures during whose production
no measurement is made of the pen trajectory or dynamics. Let us call such signatures,
for which we have only a static visual record, off-line, and let us call signatures during
whose production the pen trajectory or dynamics or pen-ups is captured, on-line. Whereas
attempts to automate the verification of off-line signatures have fallen well short of
human performance to this point, we shall demonstrate that automatic on-line signature
verification is feasible.
In a break with tradition, we challenge the notion that the success of automatic online
signature verification hinges on the capture of velocities or forces during signature
production. Whereas velocities and forces can assist us in automatic on-line signature
verification, we contend that we should not depend on them solely, or even primarily. If
we were indeed unavoidably consistent over the dimensions of time and force when we
signed, the use of pen dynamics during signature production — over and above that of
signature shape — would be very useful in detecting forgeries, as dynamic information
pertinent to a signature is not as readily available to a potential forger as is the shape of
the signature, given just the signature’s off-line specimens.
However, we have seen no substantive evidence to the effect that our pen dynamics is as
consistent as, or more consistent than, our final signature shape when we sign. Our own
University Reg. No:224387 Human Signature Verification1
Rajagiri School of Engineering & Technology, Kakkanad
informal experiments indicate that we typically exhibit similar temporal variations over
the production of similar handwritten curves: In general, our speed along high-curvature
curve segments is low relative to our speed along low-curvature curve segments, our
average overall speed varying greatly from one instance of a pattern to another
irrespective of whether we are producing our own pattern or forging someone else's.
This observation suggests that at least the requirement of consistency over time during
signature production is of limited value beyond that of consistency over shape. At any
rate, irrespective of the velocities and forces generated during the production of a
signature, for us to declare two signatures to be produced by the same individual, clearly,
it is necessary that the shapes of the signatures match closely.
1.1. Problem statement
This project is concerned with the design of accurate signature-verification techniques.
The presented methods are specifically developed to cope with huge amount of data
variations that are present in on-line signature. Emphasis is put on reliable verification of
intra-class signatures. Further, the solutions should serve as basis for additional signature-
verification domains, that is, signatures obtained using tablet PCs, touch screens panels
etc.
The proposed system is an on-line based signature verification system. Dynamic
signature verification uses both geometric features and dynamic features, such as the time
taken for the signature for signature verification.
Usually dynamic signature characteristics are taken using a special graphics pen and
tablet, but here we make use of an easily available and inexpensive hardware, the mouse
for capturing the dynamicity.
Thus, the project is concerned with the development of an On-line Mouse-based
Signature Verification System. This involves the capture of the position and shape of the
signature as well as the dynamics or pen-ups of the signature for verification of a
University Reg. No:224387 Human Signature Verification2
Rajagiri School of Engineering & Technology, Kakkanad
person’s identity.
The work of this project is not limited to the use within signature-verification, but shall
also be easily transferable to general pattern recognition problems.
1.1 Supporting information
The following extract gives an observed proof that mouse signatures do not differ much
when compared to sign atures signed using a pen, for example. The research conducted
over this has given us solid ground to pursue the development of our proposed signature-
verification system.
Extract from Mouse Based Signature Verification for Secure Internet Transactions by
Hansheng Lei, Srinivas Palla and Venu Govindaraju, CUBS, State University of New
York at Buffalo, Amherst, NY.
It is understandable that people prefer pen writing to mouse writing in day-to-day
situations because of convenience. However, to transfer the techniques of on-line
signature verification to the internet, we must study the possibility of signing signatures
using mouse. It is infeasible to expect common users have digital tablet while performing
Internet transactions.
At the first sight, writing with mouse is quite difficult. But, the face is that mouse writing
is also smooth and convenient. However, practice demonstrated that mouse written
signatures can be as good as pen written signatures.
The only drawback is that mouse written should be relatively slow and not very cursive.
The similarities also demonstrated that mouse written signatures and pen written
signatures have no intrinsic difference. Therefore, the standard on-line signature
verification techniques are also applicable in mouse based signature verification.
It was also observed that the configuration of Personal Computer (PC) where the mouse
signature samples are collected has impact on the convenience of mouse writing. For
University Reg. No:224387 Human Signature Verification3
Rajagiri School of Engineering & Technology, Kakkanad
example, it seemed that the mouse writing on a PC with Pentium® 4 2.20GHz CPU and
512MB RAM was much smoother than on a laptop with Pentium® 3 700MHz and
256MB RAM. Therefore, we believe that as the configuration of PC advances and
possible development of mouse itself, the mouse writing can approach the convenience of
pen writing and thus the mouse based signature applications will be more widely adopted.
1.2 Previous work
Many research and papers have been presented on On-line Signature Verification over
the past decade. Some of them include practical applications of techniques, proposed
theories and mathematical concepts that can be included in making on-line signature
verification more successful and flawless. Although more work has been done on off-line
verification, a wide range of methods for on-line handwritten signature verification have
been reported.
Depending on the signal capture device used, features such as velocity, pen pressure and
pen tilt are used in on-line verification in addition to spatial (derived from (x, y)
coordinates) features.
Some of the techniques employed with respect to signature verification are based on
Hidden Markov Models (HMM), Fuzzy Neural Network Driven Dynamic Time Warping,
Generalized Regression Model for Clustering Linear Sequences (GRM) and Extended
Regression Technique combined with optimal alignment.
1.3 Features of the proposed system
1. Dynamic Signatures Verification – the system utilizes distinctive dynamic aspects of
the handwritten signature such as time (pen-ups) along with static feature such as
shape and position of the signature.
2. Easily available and inexpensive hardware – uses mouse for capturing the signature.
3. High Security Concept – secure storage and communication for signature data.
4. Versatile Threshold Factor – enabling a varying authentication process for different
University Reg. No:224387 Human Signature Verification4
Rajagiri School of Engineering & Technology, Kakkanad
environments, allowing organizations to easily adjust the balance between customer
acceptance and security.
5. Clear & Fast Verification Results – the verification is performed in a transparent
manner. The server compares the signature to the updated personal profile in the
database and enables or rejects the entry within milliseconds.
6. Audit Trail – detailed protocol of users’ security relevant actions (enrollment,
signature verification, suspension of signature profiles).
7. Small Sized Profile Files – the Personal Profiles require only a few hundred bytes of
storage space regardless of the signature size and complexity.
8. High Accuracy Level – by capturing all hand movements to guarantee the highest
level of accuracy and flexibility. A very accurate personal profile for authentication is
created over time when a series of signatures are accumulated for an individual.
9. Migration of existing signature samples – the load of existing biometric signature
records can be used by the Biometric Server, eliminating the need to start building a
database from scratch.
10. Seamless Integration – using an extensive API that allows biometric authentications
and enrollment of profiles to be an integrated part of any legacy application.
11. Dynamic – has the ability to adjust dynamically to all future, inherent changes in the
person’s signature. As the Biometric Server tracks each person’s natural fluctuations
over time, the profile continues to learn and remains updated and reliable over time.
12. Easy Management – the signature profile database is easily managed, enabling the
administrator to perform a series of operations for each profile including suspending,
resetting or deleting the profile.
University Reg. No:224387 Human Signature Verification5
Rajagiri School of Engineering & Technology, Kakkanad
2. LITERATURE SURVEY
According to Lei, one of the most reliable features is the shape of the signature. The next
reliable feature is the time of writing. Due to lack of benchmark databases for on-line
signatures, we will not argue the consistency of these features here but pro pose a novel
similarity measure for signature verification.
Given two signatures to compare, it is natural to ask “How similar are they?” or “What is
their similarity?” It is intuitive to answer the similarity with a value between 0% - 100%
and this value should make sense. For example, when we quantize the similarity of two
signatures as 90%, they should be very close to each other objectively, even it is
subjective to say how similar they are.
No matter what kind of features is extracted, such a similarity measure is unavoidable.
Euclidean distance, DTW (Dynamic Time Warp ing) or other distances are of relative
meaning. That is the distance itself cannot give us any information about similarity
without comparing it with other distances. We observed that R2 is a good similarity
measure with intuitive meaning. Given two sequences, R2 answers the similarity with a
value between 0% -100%. This kind of similarity measure is very useful for signature
verification, especially noting that only few genuine signatures are available in practice.
However, R2 comes from SLR (Simple Linear Regression) which traditionally measure
two 1- D sequences. We extend R2 to ER2 for multidimensional sequence matching.
Also, the optimal alignment by DTW (Dynamic Time Warping) is coupled into ER2 to
enhance robustness of signature verification.
We first provide the background of SLR and R2.Then, we extend 1D R2 to
multidimensional ER2. Then,we combine DTW and ER2 together for signature
verification
University Reg. No:224387 Human Signature Verification6
Rajagiri School of Engineering & Technology, Kakkanad
2.1 Simple Linear Regression background
Given two sequences X = (x1, x2, …, xn), Y = (y1, y2, … , yn), linear regression
statistically analyses the distribution of points (x1, y1), (x2, y2), … , (xn, yn) in the X-Y
space. If X and Y has strong linear relation, i.e., Y = ß0 + ß1X, we can expect the
distribution of these points is along a line, called the regression line.
Figure 2.1 shows an example.
Figure 2.1. Two pairs of sequences. R 2 (X1 , X 2) = 91% and R 2 (X3 , X4 ) = 31%.
X1 and X2 have high similarity because the points in c) and distributed along
a line. X3 and X4 have low similarity with scattered distribution in f)
To regress sequence Y on X, we first establish a model: Y = ß0 + ß1 X + u, where u is
the error term. Note that u = (u1 , u2 …, un ). Then we estimate the parameter ß0 and ß1
in the sense of minimum-sum-of-squared-error, i.e., ∑ui² = ∑(yi – (ß0 + ß1 xi ))² is
minimized.
University Reg. No:224387 Human Signature Verification7
Rajagiri School of Engineering & Technology, Kakkanad
From a geometric point of view, we estimate the regression line which is determined by
ß0 and ß1 so that the line fits the points in the X-Y space as close as possible.
Let Q (ß0 , ß1 ) = ∑ui²
Note that Q is a function of ß0 and ß1 . To minimize Q (ß0 , ß1 ), we have dQ/dß0 = 0
and dQ/dß1 = 0. Starting from this, we can obtain the following results.
ß0 = Y’ – ß1 X’
And
n
∑ (x – X’) (y – Y’)
i=1
ß1= ------------------ --- --- ---- ---- --- --- -
n
∑(x – X’)²
i=1
n n
where X’ = 1/n ∑ xi , Y’ = 1/n ∑ yi .
i=1 i=1
With ß0 and ß1 as above, the regression line is determined. There remains a question:
How well the regression line fits the points in the X-Y space? As a measure of the
goodness-of-fit,
R-squared is defined as:
n
∑ u i ²
i=1
R ² = 1 - -------------------------------
n
∑ (yi – Y’) ²
i=1
University Reg. No:224387 Human Signature Verification8
Rajagiri School of Engineering & Technology, Kakkanad
R-squared is also called the coefficient of determination. It can be interpreted as the
fraction of the variation in Y that is explained by X.
R-squared can be derived as:
n
∑[(xi – X’) (yi – Y’)]²
i=1
R² = ------------------------------------------------
n n
∑(xi – X’)² ∑(yi – Y’)²
i=1 i=1
R2 has the following properties:
• Reflexivity , i.e., R 2 (X, X) = 1
• Symmetry , i.e., R (X, Y) = R (Y, X). According to equation, no matter Y regresses
on X or X regresses on Y, R 2 is the same.
• R2 € [0, 1]. The closer the value to 1, the more the points tend to fall along the
regression line, thus, the stronger linear relation the two sequences have. R2= 1 means
the two sequences have perfect linear relation, while R2 = 0 means they have no
linear relation at all.
Based on the properties of R2 as above, R2 is defined as the confidence of the linear
relationship. Also, R2 is a good measure for similarity. Figure 2.1 show examples that
high (low) R2 value means high (low) similarity. Threshold based on R2 is much more
intuitive than some distance tolerance €, such as Euclidean distance or DTW distance.
Given two sequences, R 2 directly tells their similarity.
University Reg. No:224387 Human Signature Verification9
Rajagiri School of Engineering & Technology, Kakkanad
2.2 Extending R2 to ER2
Traditionally, SLR is only applied to 1-dimension al sequence. However, many kinds of
sequences are multidimensional. For an instance, the on-line handwritten signature
sequence is multidimensional, including coordinates (x and y), pressure, inclination, etc.
To match M-dimensional sequence, we define ER (Extended R-squared) as:
m n
[ ∑ ( ∑[(xi – X’) (yi – Y’))]²
j=1 i=1
ER² = ------------------------------------------------
m n m n
∑ ∑(xi – X’)² ∑ ∑(yi – Y’)²
j=1 i=1 j=1 i=1
Where Xj’ (Yj’ ) is the average of the j-dimension of sequence X (Y).
ER2 has similar properties as R , i.e., reflexivity, symmetry and ER2 € [0, 1]. The only
difference is that ER2 can measure multidimensional sequences. Just like R2, ER2
directly tells how similar they are. In contrast, DTW or Euclidean norms can only give a
distance with relative meaning.
Figure 2.2 shows examples that ER 2 makes sense. Signature (a) and (b) are genuine
signatures. Signature (c) and (d) are forgeries, although they are made by the same
person.
We can see that signature (a) has high similarity with signature (b). The ER2 between them is as high as 96.7%.
University Reg. No:224387 Human Signature Verification10
Rajagiri School of Engineering & Technology, Kakkanad
Figure 2.2. Four signatures and their similarities with each other defined by ER2.We can
see that similarity measure by ER is much more intuitive that the “distance”,
such as DTW or Euclidean distance.
The major difference in signature (c) is that the “@” is replaced by “a”. So, the similarity
between (c) and the genuine ones drops to 68.4% or 70.5%. Signature (d) is made up of
two Chinese characters. The first character is the same as the other signatures which the
second one is totally different from “@cubs”. Therefore, its similarities with other
signatures are all below 50%. This example also demonstrates that ER2 is a language-
independent measure.
2.3 Combining DTW and ER2
University Reg. No:224387 Human Signature Verification11
Rajagiri School of Engineering & Technology, Kakkanad
ER2 has its drawbacks. It only allows one-one matching between two sequences, just like
Euclidean norm. If two sequences are not aligned very well or they have different
lengths, ER2 cannot be applied directly. Usually, signature sequences are neither of the
same length nor well aligned, even by the same person. It is well known that DTW is able
to determine the optimal alignment between two sequences with different lengths.
Therefore, DTW is combined with ER2 to unify their advantages.
2.4 Dynamic Time Warping
2.4.1 Motivation
Dynamic Time Warping (DTW) is a technique that finds the optimal alignment between
two time series if one time series may be warped non-linearly by stretching or shrinking
it along its time axis. This warping between two time series can then be used to find
corresponding regions between the two time series or to determine the similarity between
the two time series. Dynamic Time Warping is often used in speech recognition to
determine if two waveforms represent the same spoken phrase. In a speech waveform, the
duration of each spoken sound and the interval between sounds are permitted to vary, but
the overall speech waveforms must be similar. In addition to speech recognition, DTW
has also been found useful in many other disciplines, including data mining, gesture
recognition, robotics, manufacturing and medicine. DTW is commonly used in data
mining as a distance measure between time series. An example of how one time series is
“warped” to another is shown in the figure 2.3 below.
University Reg. No:224387 Human Signature Verification12
Rajagiri School of Engineering & Technology, Kakkanad
Figure 2.3. Dynamic Time Warping
In the figure, each vertical line connects a point in one time series to its correspondingly
similar point in the other time series. The lines actually have similar values on the y-axis
but have been separated so the vertical lines between them can be viewed more easily. If
both the time series in figure were identical, all of the lines would be straight vertical
lines because no warping would be necessar y to ‘line up’ the two time series. The warp
path distance is a measure of the difference between the two time series after they have
been warped together, which is measured by the sum of the distances between each pair
of points connected by the vertical lines in figure. Thus, two time series that are identical
except for localized stretching of the time axis will have DTW distances of zero.
2.4.2 Dynamic Time Warping – overview
A distance measurement between time series is needed to determine similarity between
time series and for time series classification. Euclidean distance is an efficient distance
measurement that can be used. The Euclidean distance between two time series is simply
the sum of the squared distances from each nth point in one times series to the nth point
in the other. The main disadvantage of using Euclidean distance for time series data is
that its results are very unintuitive. If two time series are identical, but one is shifter
slightly along the time axis, then Euclidean distance may consider them to be very
different from each other. Dynamic Time Warping (DTW) was introduced to overcome
this limitation and give intuitive distance measurements between time series by ignoring
both global and local shifts in the time dimension.
University Reg. No:224387 Human Signature Verification13
Rajagiri School of Engineering & Technology, Kakkanad
The dynamic time warping problem is stated as follows. Given two time series X, and Y,
of lengths |X| and |Y|,
X = x1 , x2 ,…
Y = y1 , y2 ,...
Construct a warp path W, W = w1 , w2 , .., wk , max(|X|, |Y|) <= K <= |X|+|Y| where K
is the length of the warp path and the kth element of the warp path is wk = (i, j) where i
is an index from time series X, and j is an index from time series Y. The warp path must
start at the beginning of each time series at w1= (1, 1) and finish at the end of both time
series at wk= (|X|, |Y|). This ensures that every index of both time series isused in the warp
path. There is also a constraint on the warp path that forces i and j to be monotonically
increasing in the warp path, which is why the lines represent warp path is Figure 2.4. do
not overlap. Every index of each time series must be used. Stated more formally
wk = (i, j), wk+1 = (i', j’) i<=i’<=i+1, j<=j’<=j+1
The optimal warp path is the minimum-distance warp path, where the distance of a warp
path W is Dist (W) = k=1Σ k=K Dist (wki , wkj ). Dist (W) is the distance (typically
Euclidean distance) of the warp path W, and Dist (wki,wkj ) is the distance between the
two data points indexes (one from X and one from Y) in the kth element of the warp path.
A dynamic programming approach is used to find this minimum-distance warp path.
Instead of attempting to solve the entire problem at once, solutio ns to sub-problems are
found, and used to repeatedly find solutions to a slightly larger problem until the solution
is found for the entire time series.
A two-dimensional |X| by |Y| cost matrix D, is constructed where the value at D (i, j) is the
minimum-distance warp path that can be constructed from the two time series X’ = x1 ,..
xi and Y’ = y1,.. yi . The value at D (|X|, |Y|) will contain the minimum-distance warp
path between time series X and Y. Both axes of D represent time. The x-axis is the time of
University Reg. No:224387 Human Signature Verification14
Rajagiri School of Engineering & Technology, Kakkanad
time series X, and the y-axis is the time of time series Y.
Figure 2.4. A cost matrix with the minimum-distance warp path traced through it
The cost matrix and warp path is Figure 2.4 is for the same two time series shown in
Figure 2.4. The warp path is W = {(1,1), (2,1), (3,1), (4,2), (5,3), (6,4), (7,5), (8,6), (9,7),
(9,8), (9,9), (9,10), (10,11), (10,12), (11,13), (12,14), (13,15), (14,15), (15,15), (16,16)}.
If the warp path passes through a cell D (i, j) in the cost matrix, it means that the ith point
in time series X is warped to the jth point in time series Y. Notice that where there are
vertical sections of the warp path, a single point in time series X is warped to multiple
points in time series Y, and the opposite is also true where the warp path is a horizontal
line. Since a single point may map to multiple points in the other time series, the time
series do not need to be of equal length. If X and Y were identical time series, the warp
path through the matrix would be a straight diagonal line.
To find the minimum-distance warp path, ever cell of the cost matrix must be filled. The
rationale behind using a dynamic programming approach to this problem is that since the
value at D (i, j) is the minimum warp distance of two time series of lengths i and j, if the
minimum warp distances are already known for all slightly smaller portions of that time
series that are a single data point away from length i and j, then the value at D (i, j) is the
minimum distance of all possible warp paths for time series that are one data point smaller
University Reg. No:224387 Human Signature Verification15
Rajagiri School of Engineering & Technology, Kakkanad
than i and j, plus the distance between the two points xi and yj. Since the warp path must
either be incremented by one or stay the same along the i and j axes, the distance of the
optimal warp path one data point smaller than lengths i and j are contained in the matrix at
D(i-1, j), D(i, j-1) and D(i-1, j-1). So the value of a cell in the cost matrix is
D (i, j) = cost (xi, yj) + min {D (i-1, j), D (i-1, j -1), D (i, j-1 )}
After the entire matrix is filled, a warp path must be found from D (1, 1) to D (|X|, |Y|).
The warp path is actually calculated in reverse order starting at D (|X|, |Y|). A greedy
search is performed that evaluates cells to the left, down and diagonally to the bottom-left.
Whichever of these three adjacent cells has the smallest value is added to the beginning of
the warp path found so far, and the search continues from that cell. The search stops when
D (1, 1) is reached.
Dynamic Time Warping constructs a matching path in a more complex way. It is based on
linear matching, but has three conditions or constraints that need to be satisfied. These
conditions are called the continuity condition, the boundary condition and the
monotonicity condition.
2.4.2.1. Continuity Condition
The continuity condition decides how much the matching is allowed to differ from linear
matching. This condition is the core of Dynamic Time Warping and thus is not optional. If
N1 and N2 are the number of points in the first and second curve, respectively, the ith
points of the first curve and the jth points of the second curve can be matched if
(N2/N1)i – cN2 <= j <= (N2/N1)i + cN2
The c parameter determines the amount that the matching is allowed to differ from linear
matching. If c=1, the continuity condition has no effect (ever point of the first curve
matches with every point of the second curve), if c=0, the resulting match is exactly the
University Reg. No:224387 Human Signature Verification16
Rajagiri School of Engineering & Technology, Kakkanad
same as linear matching. Figure 2.5. shows how this condition puts a constraint on the
matching path. In this matching path, the matches corresponds to the crossed squares in
the path are prohibited (when c=0.4)
Figure 2.5. Continuity Condition
2.4.2.2. Boundary Condition
The boundary condition, if turned on, forces a match between the first points of the curves
and a match between the last points of the curves. If this condition is turned on, the named
points are matched, whether the continuity condition agrees o r not and whether the points
are nearest or not. Figure 2.6. shows how this condition puts a constraint on matching
path.The first points of the two curves and the last points of two curves are forced to
match.
Figure 2.6. Boundary Condition
University Reg. No:224387 Human Signature Verification17
Rajagiri School of Engineering & Technology, Kakkanad
2.4.2.3. Monotonicity Condition
The Monotonicity condition is a condition that prevents the matching from “going back in
time”. If at some point in the matching process it is decided that the ith point of the first
curve matches with the jth point of the second curve, it is not possible for an y point of the
first curve with index > i to match with a point of the second curve with index < j and for
an y point on the first curve with index < i to match with any point on the second curve
with index > j.
Figure 2.7. illustrates this condition. After the matching of the 5 shown point’s
combinations, the matches orresponding to the crossed squares in the path are prohibited
by this condition.
Figure 2.7. Monotonicity Condition
2.5. ER2 coupled with optimal alignment
We first use the DTW to determine the optimal alignment between two sequences. Then,
we stretch the two sequences to have the same len gth. If is done like this: if point xi in the
sequence X is aligned to k (k>1) points in sequence Y, we stretch X by duplicating xi k-1
times. For sequence Y, we stretch it in the same way. After stretching, the two sequences
have the same length. Then, we can feel free to apply the Extended Regression equation to
calculate similarity.
University Reg. No:224387 Human Signature Verification18
Rajagiri School of Engineering & Technology, Kakkanad
Figure 2.7. ER2 coupled with optimal alignment
The path determined by DTW I the n-by-m matrix has the minimum cumulative cost. The
marked area is the constraint that path cannot go. The path indicates the optimal
alignment: (x1 , y1 ), (x 2, y2 ),…, (xn , ym).
2.6. Java
Like the successful computer languages that came before, Java is a blend of the best
elements of its rich heritage combined with the innovative concepts required by its
unique environment.Although Java has become inseparably linked with the online
environment of the Internet, it is important to remember that Java is first and foremost a
programming language. Computer language innovation and development occurs for two
fundamental reasons: to adapt to changing environments and uses and to implement
refinements and improvements in the art of programming. The creation of Java was
driven by both elements in nearly equal measure.
Java is related to C++, which is a direct descendent of C. Much of the character of Java is
inherited from these two languages. From C, Java derives its syntax. Many of Java’s
objectoriented features were influenced by C++. In fact, several of Java’s defining
characteristics come from – or are responses to – its predecessors. Moreover, the creation
of Java was deeply rooted in the process of refinement and adaptation that has been
occurring in the computer programming languages for the past three decades.
University Reg. No:224387 Human Signature Verification19
Rajagiri School of Engineering & Technology, Kakkanad
The reach and power of Java continues to be felt in the world of computer language
development. Many of its innovative features, constructs, and concepts have become part
of the baseline for any new language. The success of Java is simply too important to
ignore. Perhaps, the most important example of Java’s influence is C#. Recently created
by Microsoft to support the .NET Framework, C# is closely related to Java. For example,
both share the same general C++ style syntax, support distributed programming and
utilize the same object model. There are, of course, differences between Java and C#, but
the overall “look and feel” of these languages is very similar. This cross-pollination from
Java to C# is the strongest testimonial to date that Java redefined the way we think about
and use a computer language.
The Java platform has few pros and cons associated with it. But as time progressed, the
pros began to outweigh the cons.
Some of the pros of the Java platform is given below.
• Fully cross platform APIs including support for Graphics, Windowing and Multimedia.
All future APIs will be cross platform.
• Mature.
• Vast amount of libraries available. Many are free and/or open source.
• High density of object oriented design patterns put to practice compared to C#/.NET.
This makes developing complex applications much easier.
• Well designed APIs following good object oriented practice.
• The Java Community Process allows people with an investment in Java have a say.
New Java features can be proposed, discussed and voted for in a open democratic forum
• Currently supported by multiple commercial vendors.
• Although not recognized by any international standards committee, Java is an open
standard governed by Sun and the jcp members. C# is an ecma standard but without
support from Microsoft, very few third parties have been willing to implement it. Sun
also tends to be less secretive than Microsoft about their products.
University Reg. No:224387 Human Signature Verification20
Rajagiri School of Engineering & Technology, Kakkanad
• Smallest unit of distribution is a class (.class file). This helps in application
development, debugging and deployment. Having a one to one mapping between types
and the file system is simpler because file systems are well understood.
• Good IDEs are available (Netbeans®, Eclipse®). Many are free and support many
features.
2.7. Swing API
Swing is well designed and utilized the MVC design pattern extensively. Windows
Forms pales in comparison. Swing is more powerful than System Window Forms. For
example, border styles can be plugged into any component using the strategy design
pattern.
In Windows Forms, components are responsible for supplying and drawing their own
borders. Some support borders and some don’t. Unlike Microsoft, Sun understands and
embraces OOP. Microsoft prefers speed over good design (at least some of their
employees seem to anyway).
The Swing package is part of the Java Foundation Classes (JFC) in the Java platform.
The JFC encompasses a group of features to help people build GUIs, Swing provides all
the components from buttons to split panes and tables. The Swing package was first
available as an add-on to JDK 1.1. Prior to the introduction of the Swing package, the
Abstract Window Toolkit (AWT) components provided all the UI components in the
JDK 1.0 and 1.1 platforms. Although the Java 2 Platform still supports the AWT
components, it is strongly encouraged to use Swing components instead. Swing
component names begin with ‘J’. The AWT button class, for example, is named Button,
whereas the Swing button class is named JButton. In addition, the AWT components are
in the java.awt package, whereas, the Swing components are in the javax.swing package.
As a rule, programs should not use heavyweight AWT components alongside Swing
components. Heavyweight components include all the ready-to-use AWT components,
such as Menu and ScrollPane, and all components that inherit from the AWT Canvas and
University Reg. No:224387 Human Signature Verification21
Rajagiri School of Engineering & Technology, Kakkanad
Panel classes. When Swing components (and all other “lightweight” components) overlap
with heavyweight components, the heavyweight component is always painted on top.
2.8. Java Virtual Machine (JVM)
All CPUs perform the same basic operations as one another. However, programs
designed for a specific CPU will not perform on another CPU. Since there are so many
different types of processors and computers, it is a major problem for developers to write
general-purpose programs for everybody. The developers of Java decided to try to solve
this problem and created the Java Virtual Machine. The JVM is an abstraction of a CPU
which creates a virtual computer that is implemented on top of the physical machine.
This implementation allows the JVM to be installed on any machine and a program that
is written in Java2 can then be run anywhere that has the JVM installed. Depending on
the architecture of the computer, a different implementation of the virtual machine is
required. An example of one such implementation of the JVM is Sun Microsystems Java
Development Kit (JDK), which runs on Solaris and Windows operating systems.
In order to run a Java program a compiler translates the Java code into class files, which
can then be used by the JVM. The data in a class file is not necessarily stored in a file; it
can be stored in a database, over a network, as part of a Java archive file (JAR), or a
number of other ways. Java uses a class called ClassLoader which contains subclasses
that can load the data from a class file that is stored in any if the aforementioned ways.
The instructions created during the compilation process are expressed in bytecodes which
resembles the ISA of most processors. A major difference between the JVM and the ISA
of most CPUs is how each interacts with memory. The ISA of most CPUs treat memory
as if it were a large array of bytes while the JVM treats memory as a collection of objects,
which are used in Java’s object oriented paradigm. Treating memory in such a way
allows the JVM to use a stack-based architecture where objects are pushed onto the stack
as they are created and popped off as they are used and no longer needed.
The JVM is conceptually divided into four separate spaces; the class area, the Java stack,
the heap, and the native method area. The class area, where the code and constants are
University Reg. No:224387 Human Signature Verification22
Rajagiri School of Engineering & Technology, Kakkanad
kept, is divided into a method area where method implementations are kept and a
constant pool where constants reside. In order to make the JVM more stable, all of the
properties of a class, once created, are immutable. This encourages consistency amongst
the methods and objects of a particular class. The methods of a class will have the same
code each time they are invoked and all of the objects of the class will have the same
fields.
The Java stack holds methods that have been called along with the data associated with
each method. When a method is called a data space known as a stack frame is created.
The collection of stack frames for a program is known as the Java stack. Like stacks we
have studied, the latest method invocation is placed on the top of the Java stack until it is
done executing, then it is popped off of the stack and the stack frame below picks up
where it left off execution. Stack frames contain an operand stack, an array of local
variables, and a program counter which points to the currently executing instruction in
the stack frame. The heap area stores objects which are associated with a class in the
class area of the JVM. There is also space for storing the non-static fields of a class, as
well as all of the non-static fields in a class’s super class and so on. The final area of the
JVM is the native method stack. This is where methods that are not written in Java are
created and used. Native methods usually use a stack to keep track of their own state
when they are compiled into machine code.
Classes in Java are loaded in two phases: the loading phase and the linking (also known
as resolution) phase. Java has the power of reflection, which allows a program to examine
itself. Through reflection, Java can find out the fields and methods of a class and it can
even invoke methods and read or assign fields. The Class Loader uses reflection in the
loading phase to translate the class file into bytecode, a format the JVM can understand.
During the loading phase, the bytes from a class file are loaded into the JVM, where the
ClassLoader loads the super class of the super class and so on. Subclasses of ClassLoader
implement different ways of loading class files from different locations; on the disk, in a
University Reg. No:224387 Human Signature Verification23
Rajagiri School of Engineering & Technology, Kakkanad
database, over the network. The loadClass method starts the ClassLoader. Class
loadClass(String name, boolean resolve); The name is the name of the class to be loaded,
and the resolve tells whether or not to proceed to the linking phase. Then the defineClass
method checks to make sure the class file is properly formatted and it calls loadClass to
load the super class. The loadClass function loads the super class which uses the
defineClass to define it until the ClassLoader finds java.lang.Object or it detects it has
gone in a loop. If ClassLoader finds itself in a loop a ClassCircularityError is thrown.
After this process is complete, d defineClass returns a Class object. The JVM now knows
the name of the class being loaded as well as all of its super classes, and the names and
types of its fields and methods.
In the linking phase, a class is verified to make sure it meets certain criteria and is
initialized. If the parameter resolve in the loadClass method is true, the resolveClass
method is called, which verifies that classes obey certain rules. Some of the rules that
classes must follow are all methods required by interfaces are implemented, instructions
use constants that exist and that are of the correct type, methods don't overflow the stack,
and methods don't try to use an int as a reference. As long as a class follows all of the
rules it can be initialized. The JVM allocates space for all static fields and assigns default
values to the fields (0 for numbers, null for objects, or some other value if there is a
constant value associated with the field). The final step of this process is calling the
<clinit> method of the class, where the Java compiler places all the code that appears
outside of the methods. Once this step has completed successfully, the class is ready to be
executed. If some exception is thrown by the <clinit> method, the class is not ready and
an ExceptionInInitializerException is thrown by the resolveClass method from the
ClassLoader.
Verification is a very important process of loading classes into the JVM. It guarantees
that certain parts of a computer, i.e. locations in memory, are not corrupted by a program.
Certain locations in memory are reserved for the operating system and if they are altered
in any way by something other than the operating system, the machine will most likely
crash. There are different ways programs can attempt to do this. One such way is to
University Reg. No:224387 Human Signature Verification24
Rajagiri School of Engineering & Technology, Kakkanad
overflow the stack which can corrupt parts of reserved memory. Another way would be
to cast an object in order to obtain a pointer to a location in memory the program is not
allowed to access. Verification makes sure this does not happen by checking that objects
are always used in their proper manner. This is not the only role of verification; it also
makes sure that classes are structurally valid, constant references are correct, all
instructions are valid, and the stack and local variables contain values according to their
types, as well as making sure the class does in fact exist and that the class has the
necessary methods and fields.
The JVM performs all of these checks by looking at the bytecodes generated before the
program is executed. By doing this, the JVM ensures that if a program is either written
poorly, or more importantly, written with malicious intent, it will not run on the machine.
It also allows programs to be executed more quickly since it does not have to check for
certain kinds of errors.
2.9. NetBeans
The NetBeans IDE is open source and is written in the Java
programming language. It provides the services common to creating
desktop applications -- such as window and menu management,
settings storage -- and is also the first IDE to fully support JDK 5.0
features. The NetBeans platform and IDE are free for commercial and
non-commercial use, and they are supported by Sun Microsystems.
The NetBeans Platform is a generic base for desktop applications. It provides the services
common to almost all large desktop applications: window management, menus, settings
and storage, an update manager, and file access. Get a head start by reusing these
standard components, allowing you to concentrate fully on your application's business
logic.
University Reg. No:224387 Human Signature Verification25
Rajagiri School of Engineering & Technology, Kakkanad
NetBeans refers to both a platform framework for Java desktop applications, and an
integrated development environment (IDE) for developing with Java, JavaScript, PHP,
Python, Ruby, Groovy, C, C++, Scala, Clojure and much more (for a complete overview
visit the website of netbeans).
The NetBeans IDE is written in Java and runs everywhere where a JVM is installed,
including Windows, Mac OS, Linux, and Solaris. A JDK is required for Java
development functionality, but is not required for development in other programming
languages.
The NetBeans Platform allows applications to be developed from a set of modular
software components called modules. Applications based on the NetBeans platform
(including the NetBeans IDE) can be extended by third party developers.
The NetBeans Platform is a reusable framework for simplifying the development of Java
Swing desktop applications. The NetBeans IDE bundle for Java SE contains what is
needed to start developing NetBeans plugins and NetBeans Platform based applications;
no additional SDK is required.
Applications can install modules dynamically. Any application can include the Update
Center module to allow users of the application to download digitally-signed upgrades
and new features directly into the running application. Reinstalling an upgrade or a new
release does not force users to download the entire application again.
The platform offers reusable services common to desktop applications, allowing
developers to focus on the logic specific to their application. Among the features of the
platform are:
User interface management (e.g. menus and toolbars)
User settings management
Storage management (saving and loading any kind of data)
Window management
University Reg. No:224387 Human Signature Verification26
Rajagiri School of Engineering & Technology, Kakkanad
Wizard framework (supports step-by-step dialogs)
NetBeans Visual Library
The NetBeans IDE is an open-source integrated development environment. NetBeans
IDE supports development of all Java application types (Java SE including JavaFX, (Java
ME, web, EJB and mobile applications) out of the box. Among other features are an Ant-
based project system, Maven support, refactorings, version control (supporting CVS,
Subversion, Mercurial and Clearcase).
Modularity: All the functions of the IDE are provided by modules. Each module provides
a well defined function, such as support for the Java language, editing, or support for the
CVS versioning system, and SVN. NetBeans contains all the modules needed for Java
development in a single download, allowing the user to start working immediately.
Modules also allow NetBeans to be extended. New features, such as support for other
programming languages, can be added by installing additional modules. For instance, Sun
Studio, Sun Java Studio Enterprise, and Sun Java Studio Creator from Sun Microsystems
are all based on the NetBeans IDE.
NetBeans integrated modules are part of the NetBeans IDE.The NetBeans Profiler is a
tool for the monitoring of Java applications. It helps you find memory leaks and optimize
speed. Formerly downloaded separately, it is integrated into the core IDE since version
6.0.The Profiler is based on a Sun Laboratories research project that was named JFluid.
That research uncovered specific techniques that can be used to lower the overhead of
profiling a Java application. One of those techniques is dynamic bytecode
instrumentation, which is particularly useful for profiling large Java applications. Using
dynamic bytecode instrumentation and additional algorithms, the NetBeans Profiler is
able to obtain runtime information on applications that are too large or complex for other
profilers. NetBeans also support Profiling Points that let you profile precise points of
execution and measure execution time.
University Reg. No:224387 Human Signature Verification27
Rajagiri School of Engineering & Technology, Kakkanad
GUI design tool formerly known as project Matisse, the GUI design-tool enables
developers to prototype and design Swing GUIs by dragging and positioning GUI
components. The GUI builder also has built-in support for Swing Application
Framework, and Beans Binding technology.
JavaScript editor features comprise syntax highlighting, refactoring, code completion for
native objects and functions, generation of JavaScript class skeletons, generation of Ajax
callbacks from a template; and automatic browser compatibility checks.
CSS editor features comprise code completion for styles names, quick navigation through
the navigator panel, displaying the CSS rule declaration in a List View and file structure
in a Tree View, sorting the outline view by name, type or declaration order (List & Tree),
creating rule declarations (Tree only), refactoring a part of a rule name (Tree only).
3. HARDWARE AND SOFTWARE SPECIFICATIONS
The various Functional requirements are:
1. The user shall be able to authenticate himself/herself by provide his/her personal
information along with his/her signature.
2. The system shall provide a separate screen for the user to train the system.
3. Every signature shall be maintained individually with no two signatures (either inter-
class or intra-class) templates conflicting with each other.
4. The system shall provide a separate screen where in the system can be used to verify
the user’s signature.
5. The software shall maintain its integrity and will provide friendly error-messages and
help screens when appropriate.
University Reg. No:224387 Human Signature Verification28
Rajagiri School of Engineering & Technology, Kakkanad
The various Non-Functional and Domain Requirements (Product Requirements) are:
1. The system shall require a minimum of 50MB free disk space and sufficient free
memory for it to be executed at full throttle.
2. The base system requires Sun’s Java Development Kit (version 5+) to be installed
prior to the execution of the software.
3. If debugging functions are needed, Netbeans shall be installed.
4. Certain runtime libraries may be needed during the execution of the software. These
libraries, if any, shall be identified as the software is developed and will be added in the
final documentation.
3.1. HARDWARE SPECIFICATIONS
RAM : 128Mb SD RAM
Processor : Pentium III,1.13GHz
Mouse : 2-Buttoned mouse
Hard Drive : 40GB HDD
3.2. SOFTWARE SPECIFICATIONS
Netbeans IDE 6.0.1
JDK 1.6
Windows XP
University Reg. No:224387 Human Signature Verification29
Rajagiri School of Engineering & Technology, Kakkanad
4. SYSTEM ANALYSIS AND DESIGN
The proposed system is an On-line Mouse-based Human Signature Verification System.
This verifies the identity of an individual based on his signature. We consider the static
aspects: position and shape of the signature along with dynamic aspects: the time (pen-
ups) involved during the signature.
Once the problem statement and the software specification have been designed, the next
stage is the architectural design process which deals with the decomposition of sub-
systems into modules.
The various modules of the project are:
University Reg. No:224387 Human Signature Verification30
Rajagiri School of Engineering & Technology, Kakkanad
1. Training module
2. Verification module
3. Settings module
1. Training module
It involves the capture of signature from the user during the enrollment. The user is
prompted to put his/her signature using mouse in the space provided. Two signatures
would be captured for preparing the template. The signatures captured would be
normalized. The size of the signature, the pen-up and pen-down times, the x-coordinate
and y-coordinate values will be captured and a message digest will be calculated for the
signature. User will also be asked his/her firstname, lastname and the user number. The
size of the signature, the pen-up and pen-down times, the x-coordinate and y-coordinate
values and the message digest value would then be stored in a directory(folder) with the
name as firstname appended with lastname again appended with user number. This would
be a unique directory. This stored signature would then be retrieved later for verification
with the live template.
The various classes involved in training module are:
1. SignatureData class: To take the x and y coordinate position and the pen up time and
for hash code generation
Functions:
SignatureData() –To create signature data from raw signature sample
getPenUp(), setPenUp()-To get and set the pen-up times of the signature
getX(), setX()-To get and set the x-coordinates of the signature
getY(), setY()-To get and set the y-coordinates of the signature
getNum(), setNum()-To get and set the size of the signature
equals()- To return a Boolean value to indicate whether 2 signature data are same
hashCode()-Returns the hashcode for the signature
University Reg. No:224387 Human Signature Verification31
Rajagiri School of Engineering & Technology, Kakkanad
2. Enroll class: Creates a normalized signature
Functions:
enrollSignature()- For obtaining the enroll signature
min()- To get the minimum value of the coordinates
max()-To get the maximum value of the coordinates
3. Message Digest class: To calculate the message digest for the signature
4. DataIO: For storing and retrieving the signature data to and from the directory.
2. Verification module
This involves comparison of the stored signature and the captured signature for similarity
for authenticating a person. This involves time warping the stored and the captured
signature for finding the optimal alignment between two time series if one time series
may be warped non-linearly by stretching or shrinking it along its time axis. After that,
we do an extended regression of the two time series to find the similarity between them.
3. Settings module
This is used to change the look and feel, delete a user’s record and to change the
threshold value. This can be done only by an administrator and who needs to give the
username and password, which would be verified. If authorized, he would be given the
permission to change the settings.
The two models that may be used when decomposing a sub-system into modules are:
1. An object-oriented model: The system is decomposed into a set of communicating
objects.
University Reg. No:224387 Human Signature Verification32
Rajagiri School of Engineering & Technology, Kakkanad
2. A data-flow model: The system is decomposed into functional modules which accept
input data and transform it, in someway, to output data. This is also called a pipeline
approach.
These design modules are made in view of the prior specifications that are provided. The
end- product may or may not include other modules. These extra modules are often
recognized as the design is actually implemented or when new requirements arise half-
way during development process.
4.1 Object Models
An object-oriented model of system architecture structures the system into a set of
loosely coupled objects with well-defined interfaces.
Objects call on the services offered by other objects. Object classes have names and a set
of associated attributes. Operations, if any, are defined in the lower part of the rounded
rectangle representing the object. Dashed arrows indicate that an object uses the attributes
or services provided by another object.
An object-oriented decomposition is concerned with object classes, their attributes and
operations. When implemented, objects ar e created from these classes and some control
model is used to coordinate object operations. The advantages of the object-oriented
approach are well known. Because objects are loosely coupled, the implementation of
objects can be modified without affecting other objects.
Objects are often representations of real-world entities so the structure of the system is
readily understandable. Because these real-world entities are used in different systems,
objects can be reused. Object-oriented programming languages have been developed
which provide direct implementations of architectural components.
An object model for the proposed, signature-verification system is given below:
University Reg. No:224387 Human Signature Verification33
Rajagiri School of Engineering & Technology, Kakkanad
Figure 4.1.Object model of Human Signature Verification
4.2. Data Flow models
In a data-flow model, functional transformations process their inputs and produce
outputs.
Data flows from one to another and is transformed as it moves through the sequence.
Each processing step is implemented as a transform. Input data flows through these
transforms until converted to output. The transformations may execute sequentially or in
parallel.
The advantages of this architecture are:
1. It supports the reuse of transformations.
University Reg. No:224387 Human Signature Verification34
Rajagiri School of Engineering & Technology, Kakkanad
2. It is intuitive in that many people think of their work in terms of input and output
processing.
3. Evolving the system by adding new transformations in usually straightforward.
4. It is simple to implement either as a concurrent or a sequential system.
Figure 4.2. Context Level Data-flow model of Signature Verification system
Figure 4.3. Data-flow model of Signature Verification system
4.3 Use-Case Diagram
University Reg. No:224387 Human Signature Verification35
Rajagiri School of Engineering & Technology, Kakkanad
The functionality of a system is described in a number of different use-cases, each of
which represents a specific flow of events in the system. A use case corresponds to a
sequence of transactions, in which each transaction is invoked from outside the system
(actors) and engages internal objects to interact with one another and with the system’s
surroundings.
A use-case diagram is a graph of actors, a set of use cases enclosed by a system boundary,
communication associations between the actors and the use cases, and generalization
among the use cases.
The proposed use case diagram for the signature-verification system is given below:
Figure 4.4. Use case diagram for the signature-verification system
University Reg. No:224387 Human Signature Verification36
Rajagiri School of Engineering & Technology, Kakkanad
4.5 UML Dynamic Modeling (Interaction Diagrams)
Interaction diagrams are diagrams that describe how groups of objects collaborate to get
the job done. Interaction diagrams capture the behavior of a single use case showing the
patterns of interaction among objects. The diagram shows a number of example objects
and the messages passed between those objects within the use case.
4.5.1.UML Sequence Diagram.
Sequence diagrams are an easy and intuitive way of describing the behavior of a system
by viewing the interaction between the system and its environment. A sequence diagram
shows an interaction arranged in a time sequence. It shows the objects participating in the
interaction by their life-lines and the messages they exchange, arranged in a time
sequence.
An UML Sequence Diagram for validating personal information provided in the
signature-verification system is given below. It gives an abstract view of the messages
that are passed between them, along with the objects that collaborate to make this
possible.
University Reg. No:224387 Human Signature Verification37
Rajagiri School of Engineering & Technology, Kakkanad
Figure 4.5. Sequence diagram for user validation
University Reg. No:224387 Human Signature Verification38
Rajagiri School of Engineering & Technology, Kakkanad
Figure 4.6. Sequence diagram for training module
University Reg. No:224387 Human Signature Verification39
Rajagiri School of Engineering & Technology, Kakkanad
Figure 4.7. Sequence diagram for verification module
University Reg. No:224387 Human Signature Verification40
Rajagiri School of Engineering & Technology, Kakkanad
Figure 4.8. Sequence diagram for settings module
5. IMPLEMENTATION
University Reg. No:224387 Human Signature Verification41
Rajagiri School of Engineering & Technology, Kakkanad
Once the analysis and design phase are complete, we can start with the implementation of
the signature-verification system. The objects discovered durin g analysis can serve as
framework for design. The class’s attributes, methods, and associations identified during
analysis must be designed for implementation as a data type expressed in the
implementation language. New classes can be introduced to store intermediate results
during program execution.
Previously, we have introduced the logic and the mathematical concepts that we are going
to use in the proposed signature-verification system. As indicated before, we will be using
the Dynamic Time Warping (DTW) technique to “warp” the two signature series and
conclude our verification system b y using the Extended Regression technique which
gives an intuitive similarity measure.
Figure 5.1.Costmatrix d and DTW matrix
We first present the notations that are used with respect to the DTW algorithm:
University Reg. No:224387 Human Signature Verification42
Rajagiri School of Engineering & Technology, Kakkanad
5.1. Dynamic Time Warping algorithm
Dynamic Time Warping (u, v)
• Create the distance matrix
o d [i, j] = (u[i] – v[j])²
• Initialize the first element of the DTW Matrix
o D [1, 1] = d [1, 1]
• Compute the first row of D
o D [i, 1] = d [i, 1] + D [i-1, 1] for i = 2 to N
• Compute the first column of D
o D [1, j] = d [1, j] + D [1, j-1] for j = 2 to M
• Compute the rest of D
o for i = 2 to N, j = 2 to M
• D [i, j] = d [i, j] + min { D [i-1, j], D [i-1, j-1], D [i, j-1] }
o end for
• Compute Total Cost C = D [N, M]
University Reg. No:224387 Human Signature Verification43
Rajagiri School of Engineering & Technology, Kakkanad
5.2. Algorithm to compute the minimum-cost path
Minimum Cost Path (D)
• Initialize the following variables
o K = 1
o i = Length of Signature 1 i.e. N
o j = Length of Signature 2 i.e. M
• Perform the following steps while either i or j is greater than 1
o If i equals 1 then
Decrement j by 1
o Else
o If j equals 1
Decrement i by 1
o Else
Assign x with Minimum of D[i-1, j], D[i-1, j-1] and D[i, j-1]
If x corresponds to D[i-1, j] Then
• Decrement i by 1
Else If x corresponds to D[i, j-1]
• Decrement j by 1
Else
• Decrement both i and j by 1
o Assign w[K, 1] with i
o Assign w[K, 2] with j
o Increment K by 1
• The w array will contain the indexes which give the minimum-cost path when
traversed through the DTW matrix D.
5.3. Algorithm to enroll the time series signature sequences
University Reg. No:224387 Human Signature Verification44
Rajagiri School of Engineering & Technology, Kakkanad
Enroll (X, Y, N)
• Compute minimum x from the X series
• Compute maximum x from the X series
• Compute minimum y from the Y series
• Compute maximum y from the Y series
• Initialize
o i = 1
• Repeat the following steps while i less than N
o X[i] = (X[i] – minx) / (maxx – minx)
o Y[i] = (Y[i] – miny) / (maxy – miny)
• Store the normalized X and Y series into the vault.
5.4. Algorithm to compute result using ER2
ER2 (XR, YR, NR, XT, YT, NT)
• Compute mean of the reference and test series
o xrBar = mean(XR, NR)
o yrBar = mean(YR, NR)
o xtBar = mean(XT, NT)
o ytBar = mean(YT, NT)
• Calculate the numerator of the Extended Regression Formula
o For i = 0 to NR-1 do
Insum1 + = (XR[i] – xrBar) * (XT[i] – xtBar)
o For i = 0 to NR-1 do
Insum2 += (YR[i] – yrBar) * (YT[i] – ytBar)
o finalNume = Insum1 + Insum2
• Calculate the denominator of the Extended Regression Formula
o For i = 0 to NR-1 do
University Reg. No:224387 Human Signature Verification45
Rajagiri School of Engineering & Technology, Kakkanad
Xsum1 += (XR[i] – xrBar) 2
o For i = 0 to NR-1 do
Ysum1 += (YR[i] – yrBar) 2
o Sum1 = Xsum1 + Ysum1
o For i = 0 to NT-1 do
Xsum2 += (XT[i] – xtBar) 2
o For i = 0 to NT-1 do
Ysum2 += (YT[i] – ytBar) 2
o Sum2 = Xsum2 + Ysum2
o finalDeno = Sum1 * Sum2
• Divide the numerator with the denominator to obtain the final intuitive result
5.5. Algorithm to provide access layer support
Storage Vault (X, Y, N, FolderName, FileName, Flag)
• Convert String:: FolderName to lowercase
• If Flag is True Then
o Make a new directory with the directory name as specified in FolderName parameter
o If creation returns an error, then display “User Already Exists”
• Perform the following steps to record the data
o Open the file with name FileName present inside the FolderName
directory in WRITE mode
o For i = 1 to N-1 do
• Write X[i] and Y[i] into the file
o Close all File Handlers
5.6. Algorithm to conclude the result statistics
University Reg. No:224387 Human Signature Verification46
Rajagiri School of Engineering & Technology, Kakkanad
Verify Signature (XT, YT, NT)
• Read Signature 1 X and Y series from Storage Vault into XR1, YR1
• Read Signature 2 X and Y series from Storage Vault into XR2, YR2
• Do the following steps for each signature template and test pairs
o Perform DTW on XR1, YR2, NR1, XT, YT, NT
o Compute ER2 on the same and store result in RES1
o Perform DTW on XR2, YR2, NR2, XT, YT, NT
o Compute ER2 on the same and store result in RES2
o Obtain pen-ups for both signature templates and record pen-ups for the
test signature
• If all the pen-ups are equal then compute
o RESULT = AVG (RES1, RES2)
o Return the RESULT
• Else
o Return 0.0
5.7.Algorithm to provide authentication of stored data
Get Digest ()
• Get an instance of the Message Digest Algorithm
o Get an Instance of MD5 Algorithm from the “MessageDigest “ Class
present as a part of the Java Cryptography Extension (JCE)
• Create a new Digest Input Stream
• Read the input data into a buffer
• Compute the Message Digest for the input data by calling the appropriate function
o MsgDigest = Instance of Message Digest Class.digest()
• Return the computed Message Digest
5.8.Algorithm to authenticate the stored data
University Reg. No:224387 Human Signature Verification47
Rajagiri School of Engineering & Technology, Kakkanad
Authentication (Folder Na me)
• Read the previously computed digest
• Compute afresh the digest for the stored data
• Check for the following condition
o If the newly computed digest is same as the previously computed digest
then
Return TRUE
o Else
Return FALSE
6. TESTING
University Reg. No:224387 Human Signature Verification48
Rajagiri School of Engineering & Technology, Kakkanad
Software testing is a critical element of software quality assurance and represents the
ultimate review of specification, design and coding. System testing is actually a series of
different tests whose primary purpose is to fully exercise the computer-based system.
Although each test has a different purpose, all of them work to verify that all system
elements has been properly integrated and performed allocated functions. If the testing is
conducted successfully, it will uncover errors in the software. As a secondary benefit,
testing demonstrates that the software appears to be working according to specification
and that the performance requirements appear to have been met.
In addition, data collector as testing is conducted provides a good indication of software
reliability and some indication of software quality as a whole. However, testing can’t
show the absence of defects, it can only show that software errors are present. All tests
should be traceable to customer requirements. Thus a tester must understand the software
and attempt to develop a mental picture of how the software might fall.
Testing is the process of executing a program with the intention of finding an error. A
good testing is one that has a high probability of finding an as-yet undiscovered errors. A
successful test is that in which no errors are found. The objective is to design test that
systematically uncover different classes of errors and do so with a minimum amount of
time and effort.
6.1Types of testing
6.1.1Unit Testing
Unit testing focuses verification efforts even in the smallest unit of software design in
each module. This is also known as ‘Module testing’. The modules of the system are
tested separately. Unit testing is essential for the verification of the code produced during
University Reg. No:224387 Human Signature Verification49
Rajagiri School of Engineering & Technology, Kakkanad
the coding phase, and hence the goal is to test the internal logic of the module. It is
typically done by the programmer of the module.
6.1.2Integrated Testing
Integrated testing is the systematic testing to uncover the errors within the interface. This
testing is done with simple data and the developed system has run successfully with
simple data. In this many unit tested modules are combined into subsystems, which are
then tested. The goal here is to see if the modules can be integrated properly.
6.1.3.Validation Testing
Validation test is defined with a simple definition that validation succeeds when the
software function in a manner that can be reasonably accepted by the user.
6.1.4.Output Testing
After performing validation testing the next step is output testing of the proposed system.
The output format is considered in two ways. One is onscreen format and next is printed
format. The output testing does not result in any correction in the system.
6.1.5.System And Acceptance Testing
This is the key factor for the success of any system. User acceptance testing is done by
constantly keeping in touch with the prospective system at the time of development and
making changes whenever required. This is done with regard to the input screen design
and output screen design.
University Reg. No:224387 Human Signature Verification50
Rajagiri School of Engineering & Technology, Kakkanad
Levels of testing
CLIENT NEEDS ACCEPTANCE TESTING
REQUIREMENTS SYSTEM TESTING
DESIGN INTEGRATION TESTING
CODE UNIT TESTING
To simulate mouse based signature verification, an interface was built. There are
typically two steps for authentication. The first step is the enrollment where 2 signatures
are provided to create template. The second step is the verification which matches the test
sample against the corresponding template.
An experiment is shown where 40 mouse written signatures were collected from 20
subjects with 2 each. Experiment was conducted to test the performance of ER2 on
mouse written signatures. Based on the experimental conclusion, we briefly discuss
architecture of a mouse based authentication system for Internet Applications.
6.2. ER2 on mouse written signature matching
Receiver Operating Characteristic (ROC) curve is an appropriate mode for verification
performance analysis. To construct the ROC curve, we need the distribution of genuine
scores and imposter scores.
University Reg. No:224387 Human Signature Verification51
Rajagiri School of Engineering & Technology, Kakkanad
The genuine scores were generated as follows. The first two samples of each subject were
used for enrollment; the last sample was used for inquires. For each inquir y, the input
sample was matched against the enrolled two samples and the average similarity by ER 2
was returned. Thus, 1 genuine score of each subject and totally 20 genuine scores were
obtained.
The imposter scores were generated similarly. Samples from different subjects were used
as imposters. Again one inquires from each subject. Thus, totally 1 X (20-1 ) X 20 = 380
imposters’ scores was generated.
For the sake of Internet security, it is desirable the origin mouse signed signature cannot
be recovered from the representation of signatures. So, we can not use two dimensional
sequences [X, Y] directly to represent signature. A simple and secure representation is
the normalized form or X*Y (dot product of the X-, Y- coordinates). The performance of
ER2 matching on normalized representation is shown in Figure 6.1 in form of ROC
curve. The Equal Error Rate (EER) is as low as 0.47% when the threshold is set 80%.
The EER is 0.83% when the signatures were represented b y X*Y, slightly worse than the
normalized form. Therefore, we propose using the normalized form to represent the
mouse signed signatures for secure Internet transactions.
Figure 6.1. ROC curve when signatures are normalized
Test Case for Training module
University Reg. No:224387 Human Signature Verification52
Rajagiri School of Engineering & Technology, Kakkanad
SL NO: TEST CASE INPUT EXPECTED RESULT
1 Firstname, Lastname,User number,Two signature samples
Valid Template stored
2 Firstname,Lastname,User number orsignature sample space left empty
Invalid Message “Fields cannot be left empty”
Test Case for Verification module
University Reg. No:224387 Human Signature Verification53
Rajagiri School of Engineering & Technology, Kakkanad
SL NO: TEST CASE INPUT EXPECTED RESULT
1 Firstname, Lastname,User number,test signature sample
Valid Percentage of similarity obtained.If percentage lies below the threshold Message “Genuine”Else Message “Fake/ Inconsistent”
2 Firstname,Lastname,User number orsignature sample space left empty
Invalid Message “Fields cannot be left empty”
3 Template corresponding to given Firstname,Lastname,User number does not exist
Invalid
Test Case for Settings module
University Reg. No:224387 Human Signature Verification54
Rajagiri School of Engineering & Technology, Kakkanad
SL NO: TEST CASE INPUT EXPECTED RESULT
1 Correct administrator ID and password
Valid Able to change the settings: Look and Feel, Threshold value, Delete user record
2 Incorrect administrator ID and password
Invalid Not able to change the settings
7. RESULTS
University Reg. No:224387 Human Signature Verification55
Rajagiri School of Engineering & Technology, Kakkanad
Below are some of the screenshots of the signature-verification system developed. The
system has been implemented using Sun® Microsystems’ JAVA Development Kit. The
interface is created using Java Swings™ which provides the developers with an array of
features, look and feels, components etc to make the interface visually appealing. The
software package requires Java 5 (version 1.5+) and the latest version of Java Virtual
Machine installed.
7.1. Screen shots
Login window
University Reg. No:224387 Human Signature Verification56
Rajagiri School of Engineering & Technology, Kakkanad
Settings window
University Reg. No:224387 Human Signature Verification57
Rajagiri School of Engineering & Technology, Kakkanad
Main window
University Reg. No:224387 Human Signature Verification58
Rajagiri School of Engineering & Technology, Kakkanad
Training window
University Reg. No:224387 Human Signature Verification59
Rajagiri School of Engineering & Technology, Kakkanad
Verification window
University Reg. No:224387 Human Signature Verification60
Rajagiri School of Engineering & Technology, Kakkanad
University Reg. No:224387 Human Signature Verification61
Rajagiri School of Engineering & Technology, Kakkanad
8. CONCLUSION
We studied the possibility of mouse based signature verification for secure Internet
applications. Practice demonstrated that mouse can also draw sophisticated signature as
pen does. As the technology of personal computer and mouse itself advances, the
convenience of mouse writing also increases.
Using mouse to sign signatures tremendously enlarges the applications of signature
verification techniques. The immediate example is to utilize mouse signature verification
for Internet financial transactions where high security is required.
The implementation of a mouse based authentication system is simple and cost-effective.
The client-server architecture can realize such as a system.
University Reg. No:224387 Human Signature Verification62
Rajagiri School of Engineering & Technology, Kakkanad
9. FUTURE ENHANCEMENT
As time proceeds, new requirements from the proposed system may be expected from the
end-user, certain vulnerabilities may need to be addressed or certain problems may crop
up which may not be visible during its early days of usage. These changes and
enhancements are to be noted and the system has to be changed appropriately to adhere to
the changed requirements of the user.
It is still an open question as to how the reference set should be updated. The signature of
an individual usually changes over time, so a deterioration of the verification rates can be
expected if the reference set remains fixed. One possibility would be to ask the user to
periodically provide new reference signatures. This would also ensure that no forged
signatures are used for updates. An automatic update system would be most comfortable
for the user.
Also, our signature database does not contain any data from skilled forgers. It is still
unclear how such data should be collected. The results would be more valuable if true
forgeries that imitate the shape of the original signature were available. Evaluation of
human performance on distinguishing such a set of forgeries from the true signatures
could provide a baseline for system performance evaluation.
University Reg. No:224387 Human Signature Verification63
Rajagiri School of Engineering & Technology, Kakkanad
10. REFERENCES
Publications, Papers and Proceedings
[1] Vishvjit S Nalwa: Automatic On-Line Signature Verification , Bell Laboratories,
Holmdel, NJ. Proceedings of IEEE, 85(2), pp. 213-239, 1997.
[2] G Rigoll, A Kosmala: A Systematic Comparison Between On-line and Off-line
Methods for Signature Verification with Hidden Markov Models, Gerhard-Mercator-
Univerisity Duisburg, Faculty of Electrical Engineering, Dept. of Computer Science, D-
47057 Duisburg, Germany.
[3] R W Zhou, C Quek: An Automatic Fuzzy Neural Network Driven Signature
Verification System , SAS, Nanyang Technological University, Singapore 639798.
[4] Ralph Niels: Dynamic Time Warping – An intuitive way of handwriting recognition ,
Department of Artificial Intelligence / Cognitive Science, Nijmegen, the Netherlands.
[5] Hansheng Lei, Venu Govindaraju: GRM: Generalized Regression Model for
Clustering Linear Sequences , The 4 SIAM conference on Data Mining, 2004. th
[6] Hansheng Lei, Srinivas Palla and Venu Govindaraju: ER2: An Intuitive Similarity
Measure for On-line Signature Verification , CUBS, Center for Unified Biometrics and
Sensors, State university of New York at Buffalo, Amherst, NY 14260, USA.
[7] Stan Salvador and Philip Chan: FastDTW: Toward Accurate Dyna mic Time
Warping
in Linear Time and Space , Dept. of Computer Science, Florida Institute of Technology,
University Reg. No:224387 Human Signature Verification64
Rajagiri School of Engineering & Technology, Kakkanad
Melbourne, FL 32901
[8] Kruskall, J & M Liberman: The Symmetric Time Warping Problem: From
Continuous to Discrete. In Time Warps, String Edits and Macromolecules: The Theory
and Practice of Sequence Comparison , pp. 125-161, Addison-Wesley Publishing Co.,
Reading, Massachusetts, 1983.
[9] Vuokko Vuori, Matti Aksela, Jorma Laaksonen and Erkki Oja: Adaptive character
recognizer for a hand-held device: Implementation and evaluation setup, Proceedings of
the 7 th International Workshop on Frontiers in Handwriting Recognition (IWFHR7).
[10] Sakoe H and S Chiba (1978): Dynamic Programming algorithm optimization for
spoken word recognition. IEEE Trans. Acoustics, Speech and Signal Processing, Vol.
ASSP-26
[11] Claus Bahlmann, Bernard Haasdonk and Hans Burkhardt: Online Handwriting
Recognition with Support Vector Machines – A kernel approach . Dept. of Computer
Science, Albert-Ludwigs-University Freiberg 79110, Germany.
[12] Claus Bahlmann and Bernard Haasdonk: The Writer Independent Online
Handwriting Recognition System frog on hand and Cluster Generativ e Statistical
Dynamic Time Warping . In Proc. Of the 6 th ICDAR.
[13] L Rabiner and B Juang: Fundamentals of Speech Recognition . Prentice Hall,
1993.
University Reg. No:224387 Human Signature Verification65
Rajagiri School of Engineering & Technology, Kakkanad
Online Materials
Claus Bahlmann – Frog On Hand Homepage - http://lmb.informatik.uni-
freiburg.de/people/bahlmann/data/
Venu Govindaraju - CUBS, CEDAR, University at Buffalo, SUNY -
http://www.cedar.buffalo.edu/~govind/research.html
Online Citations and Research papers galore - http://citeseer.ist.psu.edu/
University Reg. No:224387 Human Signature Verification66
Rajagiri School of Engineering & Technology, Kakkanad
11. APPENDICES
University Reg. No:224387 Human Signature Verification67