Human Signature

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


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



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



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



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.



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



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.



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



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.



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%.



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



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.



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.



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



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



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



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



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.



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.



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.



• 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



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



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



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



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.



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


http://en.wikipedia.org/wiki/Platform_(computing)

http://en.wikipedia.org/wiki/Digital_signature

http://en.wikipedia.org/wiki/Software_framework

http://en.wikipedia.org/wiki/Third_party_developer

http://en.wikipedia.org/wiki/Software_component

http://en.wikipedia.org/wiki/Java_Development_Kit

http://en.wikipedia.org/wiki/Java_Virtual_Machine

http://www.netbeans.org/

http://en.wikipedia.org/wiki/Clojure

http://en.wikipedia.org/wiki/Scala_(programming_language)

http://en.wikipedia.org/wiki/C%2B%2B

http://en.wikipedia.org/wiki/C_(programming_language)

http://en.wikipedia.org/wiki/Groovy_(programming_language)

http://en.wikipedia.org/wiki/Ruby_(programming_language)

http://en.wikipedia.org/wiki/Python_(programming_language)

http://en.wikipedia.org/wiki/PHP

http://en.wikipedia.org/wiki/JavaScript

http://en.wikipedia.org/wiki/Java_(programming_language)

http://en.wikipedia.org/wiki/Integrated_development_environment


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.


http://en.wikipedia.org/wiki/Profiler_(computer_science)

http://en.wikipedia.org/wiki/Sun_Microsystems

http://en.wikipedia.org/wiki/Sun_Java_Studio_Creator

http://en.wikipedia.org/wiki/Sun_Studio_Compiler_Suite

http://en.wikipedia.org/wiki/Sun_Studio_Compiler_Suite

http://en.wikipedia.org/wiki/Concurrent_Versions_System

http://en.wikipedia.org/wiki/Java_(programming_language)

http://en.wikipedia.org/wiki/Clearcase

http://en.wikipedia.org/wiki/Mercurial_(software)

http://en.wikipedia.org/wiki/Subversion_(software)

http://en.wikipedia.org/wiki/Concurrent_Versions_System

http://en.wikipedia.org/wiki/Version_control_system

http://en.wikipedia.org/wiki/Refactoring

http://en.wikipedia.org/wiki/Apache_Ant

http://en.wikipedia.org/wiki/MIDlet

http://en.wikipedia.org/wiki/EJB

http://en.wikipedia.org/wiki/Web_application

http://en.wikipedia.org/w/index.php?title=Java_Platform,_Mobile_Edition&action=edit&redlink=1

http://en.wikipedia.org/w/index.php?title=Java_Platform,_Mobile_Edition&action=edit&redlink=1

http://en.wikipedia.org/wiki/Java_Platform,_Standard_Edition

http://en.wikipedia.org/wiki/Open_source


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.


http://en.wikipedia.org/wiki/Autocomplete

http://en.wikipedia.org/wiki/Javascript#Compatibility_considerations

http://en.wikipedia.org/wiki/Callback_(computer_science)

http://en.wikipedia.org/wiki/Ajax_(programming)

http://en.wikipedia.org/wiki/Autocomplete

http://en.wikipedia.org/wiki/Code_refactoring

http://en.wikipedia.org/wiki/Syntax_highlighting

http://en.wikipedia.org/wiki/Swing_Application_Framework

http://en.wikipedia.org/wiki/Swing_Application_Framework

http://en.wikipedia.org/wiki/Graphical_user_interface

http://en.wikipedia.org/wiki/Swing_(Java)


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



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:



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



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.



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:



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.



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



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



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.



Figure 4.5. Sequence diagram for user validation



Figure 4.6. Sequence diagram for training module



Figure 4.7. Sequence diagram for verification module



Figure 4.8. Sequence diagram for settings module

5. IMPLEMENTATION



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:



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]



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



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)


Insum2 += (YR[i] – yrBar) * (YT[i] – ytBar)

o finalNume = Insum1 + Insum2

• Calculate the denominator of the Extended Regression Formula




Xsum1 += (XR[i] – xrBar) 2


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



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



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



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



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.



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.



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



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




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




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



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



Settings window



Main window



Training window



Verification window





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.



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.



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,



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.



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/



11. APPENDICES


Date post:	18-Nov-2014
Category:	Documents
Upload:	gabsriel
View:	109 times
Download:	0 times

Human Signature

Documents