Altered Fingerprints: Analysis and Detection

1. INTRODUCTION

Fingerprints have been in use for biometric recognition since long because of their
high acceptability, immutability and individuality. Immutability refers to the
persistence of the fingerprints over time whereas individuality is related to the
uniqueness of ridge details across individuals. The probability that two fingerprints
are alike is 1 in 1.9 x 1015 [1]. These features make the use of fingerprints
extremely effective in areas where the provision of a high degree of security is an
issue. The major steps involved in automated fingerprint recognition
include a) Fingerprint Acquisition, b) Fingerprint Segmentation, c) Fingerprint
Image Enhancement, d)Feature Extraction e) Minutiae Matching, f) Fingerprint
Classification. Fingerprint acquisition can either be offline (inked) or Online (Live
scan). In the inked method an imprint of an inked finger is first obtained on a
paper, which is then scanned. This method usually produces images of very poor
quality because of the non-uniform spread of ink and is therefore not exercised in
online AFIS. For onlinefingerprint image acquisition, capacitative or optical
fingerprint scanners such as URU 4000, etc. are utilized which make use of
techniques such as frustrated total internal reflection (FTIR) [2], ultrasound total
internal reflection [3], sensing of differential capacitance [4] and non contact 3D
scanning [5] for image development. Live scan scanners offer much greater image
quality, usually a resolution of 512 dpi, which results in superior reliability during
matching in comparison to inked fingerprints. Segmentation refers to the separation
of fingerprint area (foreground) from the image background [6]. Segmentation is
useful to avoid extraction of features in the noisy areas of fingerprints or the
background. A Simple thresholding technique [7] proves to be ineffective because
of the streaked nature of the fingerprint area. The presence of noise in a fingerprint
image requires more vigorous techniques for effective fingerprint segmentation.
A good segmentation method should exhibit the following characteristics [8]:
􀂃 It should be insensitive to image contrast
􀂃 It should detect smudged or noisy regions
􀂃 Segmentation results should be independent of whether the input image is an
enhanced image or a raw image
􀂃 The segmentation results should be independent of
image quality Ren et al.proposed an algorithm for segmentation that employs
feature dots, which are then used to obtain a close segmentation curve. The authors
claim that their method surpasses directional field and orientation based methods
for fingerprint image segmentation. Shen et al. proposed a Gabor filter based
method in which eight Gabor filters are convolved with each image block and the
variance of the filter response is used both for fingerprint segmentation and quality
specification. Xian et al proposed a segmentation algorithm that exploits a block’s
cluster degree, mean and variance. An optimal linear classifier is used for
classification with morphological post-processing to remove classification errors.
Bazen et al. proposed a pixel wise technique for segmentation involving a linear
combination of three feature vectors (i.e. gradient coherence, intensity mean and
variance). A final morphological post-processing step is performed to eliminate
holes in both the foreground and background. In spite of its high accuracy this
algorithm has a very high computational complexity, which makes it impractical
for real time processing. Klein et al. proposed an algorithm that employs HMMs to
remove the problem of fragmented segmentation encountered during the use of
different segmentation algorithms.
1.1 Company Profile
1.2 Project overview

In the modern computerized world, it has become more and more important
to authenticate people in a secure way. Modern applications like online banking or
online shopping use techniques that depend on personal identification numbers,
keys, or passwords. Nevertheless, these technologies imply the risk of data being
forgotten, lost, or even stolen. Therefore biometric authentication methods promise
a unique way to be able to authenticate people. A secure and confidential biometric
authentication method is the utilization of fingerprints. Usually a technique called
minutiae matching is used to be able to handle automatic fingerprint recognition
with a computer system.

2. SYSTEM ANALYSIS
2.1 Feasibility System
 Preliminary investigation examine project feasibility, the likelihood the system
will be useful to the organization. The main objective of the feasibility study is to
test the Technical, Operational and Economical feasibility for adding new modules
and debugging old running system. All system is feasible if they are unlimited
resources and infinite time. There are aspects in the feasibility study portion of the
preliminary investigation:

 Technical Feasibility
 Operational Feasibility
 Economical Feasibility

TECHNICAL FEASIBILITY

The technical issue usually raised during the feasibility stage of the
investigation includes the following:

 Does the necessary technology exist to do what is suggested?

 Do the proposed equipments have the technical capacity to hold the data
required to use the new system?
 Will the proposed system provide adequate response to inquiries, regardless of
the number or location of users?
 Can the system be upgraded if developed?
 Are there technical guarantees of accuracy, reliability, ease of access and data
security?
Earlier no system existed to cater to the needs of ‘Secure Infrastructure
Implementation System’. The current system developed is technically feasible. It is
a web based user interface for audit workflow at NIC-CSD. Thus it provides an
easy access to the users. The database’s purpose is to create, establish and maintain
a workflow among various entities in order to facilitate all concerned users in their
various capacities or roles. Permission to the users would be granted based on the
roles specified. Therefore, it provides the technical guarantee of accuracy,
reliability and security. The software and hard requirements for the development of
this project are not many and are already available in-house at NIC or are available
as free as open source. The work for the project is done with the current equipment
and existing software technology. Necessary bandwidth exists for providing a fast
feedback to the users irrespective of the number of users using the system.

OPERATIONAL FEASIBILITY

Proposed projects are beneficial only if they can be turned out into
information system. That will meet the organization’s operating requirements.
Operational feasibility aspects of the project are to be taken as an important part of
the project implementation. Some of the important issues raised are to test the
operational feasibility of a project includes the following: -

 Is there sufficient support for the management from the users?

 Will the system be used and work properly if it is being developed and
implemented?
 Will there be any resistance from the user that will undermine the possible
application benefits?
This system is targeted to be in accordance with the above-mentioned issues.
Beforehand, the management issues and user requirements have been taken into
consideration. So there is no question of resistance from the users that can
undermine the possible application benefits.

The well-planned design would ensure the optimal utilization of the computer
resources and would help in the improvement of performance status.
ECONOMICAL FEASIBILITY

A system can be developed technically and that will be used if installed must
still be a good investment for the organization. In the economical feasibility, the
development cost in creating the system is evaluated against the ultimate benefit
derived from the new systems. Financial benefits must equal or exceed the costs.

The system is economically feasible. It does not require any addition

hardware or software. Since the interface for this system is developed using the
existing resources and technologies available at NIC, There is nominal expenditure
and economical feasibility for certain.

2.2EXISTING SYSTEM:
In Existing System, since existing fingerprint quality assessment algorithms
are designed to examine if an image contains sufficient information (say, minutiae)
for matching, they have limited capability in determining if an image is a natural
fingerprint or an altered fingerprint. Obliterated fingerprints can evade fingerprint
quality control software, depending on the area of the damage. If the affected
finger area is small, the existing fingerprint quality assessment software may fail to
detect it as an altered fingerprint.

2.3PROPOSED SYSTEM:
 In Proposed System was evaluated at two levels: finger level and subject
level. At the finger level, we evaluate the performance of distinguishing between
natural and altered fingerprints. At the subject level, we evaluate the performance
of distinguishing between subjects with natural fingerprints and those with altered
fingerprints.
The proposed algorithm based on the features extracted from the orientation
field and minutiae satisfy the three essential requirements for alteration detection
algorithm:
1) Fast operational time,
2) High true positive rate at low false positive rate, and
3) Ease of integration into AFIS.

3. SYSTEM CONFIGURATION
3.1Hardware Specification

 Processor : Intel I3 Core Processor

 Ram : 4 GB (or) Higher
 Hard disk : 1TB

3.2Software Specification

 Web Server : Apache Tomcat Latest Version

 Server-side : Java, Java Server Pages

Technologies

 Client-side : Hyper Text Markup Language, Cascading

Technologies Style Sheets, Java Script, AJAX

 Database Server : MS SQL

 Operating System : Windows (or) Linux (or) Mac any version

3.3About the software

OVERVIEW OF JAVA

Java was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed

Frank and Mike Sheridan at Sun Microsystems Inc.in 1991. It took 18
months to develop the first working version. This language was initially
called “Oak” but was renamed as “Java” in 1995. Between the initial
implementation of Oak in the fall of 1992 and the public announcement of
Java in the spring of 1995, many more people contributed to the design
and evolution of the language.

The main properties of the Java, which made Java so popular, are as
follows:
1. Simple
2. Secure
3. Portable
4. Object-Oriented
5. Robust
6. Multithreaded
7. Architecture-Neutral
8. Interpreted
9. High performance
10.Distributed
11.Dynamic
The most striking feature of the language is that is a platform-neutral
language. Java is first programming language that is not tied to any
particular hardware or operating system. Programs developed in Java can
be executed anywhere on any system.

THE KEY FEATURES OF JAVA IS BYTE CODE:

The key that allows Java to solve both the security and the
portability problems just described is that the output of a Java compiler is
not executable code. Rather, it is Byte code. Byte code is a highly
optimized set of instructions designed to be executed by the Java runtime
systems, which is called the Java Virtual Machine (JVM). That is, in its
standard form, the JVM is an interpreter for Byte code. This may come has
a bit of surprise.

Translating a Java program into a byte code helps and makes it

much easier to run a program in a wide variety of environments. The
reason is straightforward only the JVM needs to be implemented for each
platform. Once the runtime package exists for a given system, any Java
program can run on it. Remember, although the details of the JVM will
differ from platform to platform, all interpret the same Java Byte code.

JAVA ENVIRONMENT:

Java environment includes a large number of development tools

and hundreds of classes and methods. The development tools are the part
of the system known as Java Development Kit (JDK) and the classes are
methods are part of the Java standard library (JSL), also known as the
Application Programming Interface (API).

JAVA DEVELOPMENT KIT:

The Java development kit comes with a collection of tools that

are used for developing and running Java programs. They include:

1.Applet Viewer (for viewing Java Applets)

2.Javac (Java Compiler)
3.Java (Java interpreter)
4.Javap (Java Disassembler)
5.Javah (for C header files)
6.Javadoc (for creating HTML documents)
7. Jdb (Java Debugger)

APPLICATION PROGRAMMING INTERFACE:

The Java standard library includes hundreds of classes and methods

grouped into several functional packages. Most commonly used packages are:

 Language support package: A collection of classes and methods

required for implementing basic features of java.

 Utilities package: A collection of classes to provide utility functions

such as date and time functions.
  Input/Output package: A collection of classes required for input &
output manipulations.

 Networking package: A collection of classes for communication with

other computers via Internet.

 AWT package: The abstract window toolkit package contains classes

that implements platform independent graphical user interface.

 Applet package: This includes a set of classes that allows us to

create Java applets.
OVERVIEW OF SWINGS

Swings are basically used to create a GUI look i.e. graphical user
interface. A GUI presents a pictorial interface to a program. It allows the
user to spend less time trying to remember which keystroke sequence do
what and spends more time using the program in a productive manner.

The classes that are used to create the GUI components of

swing are part of javax.swing package. These are the latest GUI
components of java2 platform. Swing Components are written, manipulated
and displayed completely in java.

Difference Between AWT & Swings:

The original GUI components from Abstract Windows Toolkit
package java.awt are tied directly to the local platforms graphical user
interface capabilities. So, a java program executing on a different java
platforms has a different appearance and sometimes even different user
interaction on each platform.

The swing component allows the programmer to specify a

different look and feel for each platform, or uniform look and feel across all
platforms. Because swing components are written in Java, they provide a
greater level of portability and flexibility than original java GUI component
i.e. AWT. Swing components are often referred as lightweight
components because they are written completely in Java so they are not
“weighed down” by complex GUI capabilities of the platform on which they
are used. Whereas AWT components that are tied to local platform are
correspondingly called heavyweight components as they rely on the local
platform windowing system to determine their functionality and their look
and feel.

The important topics that play a very vital role in swings are as
follows:

 Component: A class component defines the methods that can be

applied to an object of any subclass of component.

 Container: It is a collection of a related components, we attach

components to the contentpane i.e. Container. Here two important
methods which are important for a container are add & setLayout
where we can add any components and set the size and position of
that particular component.
 JLabel: JLabel provides text information or information on GUI. It
displays a single line of read-only text. We can add ToolTip & Icons to
JLabel.

 JtextField Or JPasswordField: these are single-line areas in which

the users can enter text from keyboard or text can simply be
displayed. JPasswordField is used to encrypt the text.

 JButton: A Button is a component the user clicks to trigger a specific

action. There are several types of buttons like Command buttons,
CheckBoxes, ToggleButtons and RadioButtons.

 JCheckBox & JRadioButton: The swing GUI component has three

types of state buttons- JToggleButtons, JCheckBox and
JRadioButton that have on/off or true/false values. A JRadioButton is
different from a JCheckBox in the there are several JRadioButton are
grouped and only one of the JRadioButton in the group can be
selected at any time.

 JComboBox: A combobox also called as drop down list provides a

list of items from which the users can make a selection.

 JList: A List display a selection of items from which the user may
select one or more items. JList support single-line selection List and
multiple-selection list.

 JPanel: This is used to arrange component in a exact location.

  JTextArea: It provides an area for manipulating multiple lines of text.

JAVA DATABASE CONNECTIVITY (JDBC)

The Java database connectivity Application Programming

Interface (API) is an API currently being designed by Sun Microsystems
that provides a Java language interface with SQL Call Level Interface
standard. This standard provides a DBMS independent interface to
relational databases that defines a generic SQL database access
framework.

The most visible implementation of the SQL CLI is Microsoft’s

ODBC (Open Database Connectivity). This API defines a common SQL
syntax and function calls that can be used by developers to send SQL
commands to and retrieve data from SQL databases. ODBC - enabled
applications make use of database drivers (similar to other device drivers)
installed on the system that allows applications to talk to a vendor’s
database. Using this methodology, all of the DBMS specific code is placed
inside the ODBC driver and the application developer is shielded from
implementation specific problems in theory. Practically speaking, it is
sometimes difficult to completely remove vendor’s specific syntax from all
ODBC operations, but in most cases, it is relatively simple task to port
ODBC to run on a new database server.

ODBC’s primary drawback is that it is written in C. Because of

the limitations inherent in the use of native methods, the JDBC designers
have designed the JDBC specification to most easily use ODBC in short-
term, but they have provided the capability long-term for JDBC to be
implemented in other ways.

NOTE: JDBC, like ODBC, is designed to be a Call Level SQL Interface.

Because many of its many of its low-level operations can be combined into
a higher level, object oriented interface, except to see Java class libraries
released in the future that provide a mapping to the underlying JDBC Calls.
This happened with ODBC almost immediately, and the majority of ODBC
developers currently use other Interface rather than using ODBC API
directly.

The JDBC API is expressed as a series of abstract Java

interfaces within the java.sql package. Here are the most commonly used
interfaces:

 java.sql.DriverManager – manages the loading and unloading of

database drivers from the underlying systems.
 java.sql.Connection – Handles the connections to a specific
database.
 java.sql.Statement – contains an SQL statement to be passed to the
database: two sub-types in this interface are the PreparedStatement
 (for executing a Pre-Compiled SQL statement) and the
CallableStatement (for executing a database stored procedure).
 java.sql.ResultSet – contains the record result set from the SQL
statement passed to the database.

STEPS REQUIRED TO ACCESS A JDBC DATABASE

The steps required to access a JDBC database should be familiar.

JDBC uses the concept of a “ Connection” handle to manage a program’s
connection to a database.

ESTABLISING A CONNECTION

The first thing we need to do is establish a connection with the

DBMS you want to use. This involves two steps :

1.Loading the driver: If, we want to use the JDBC-ODBC bridge driver,
the following code will load it :

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

Our driver documentation will give us the class name to use. For instance,
if the class name is jdbc.Driverxyz, you would load the driver with the
following line of code:
 Class.forName(“jdbc.Driverxyz”);

2. Making the connection : the second step in establishing a connection

is to have the appropriate driver connect to the
DBMS. The following line of code illustrates the general syntax:

Connection con;
Con=DriverManager.getConnection (url,”scott”,”tiger”);

This step is also simple with the hardest thing being what to
supply for URL. If you are using the JDBC-ODBC Bridge driver, the JDBC
URL will start with jdbc:odbc:. The rest of the URL is generally your data
source name or database system.

CREATING A STATEMENT

A statement needs to be created so that it can be passed to the database

for processing. This is done by calling the connection class
createStatement () method.

Syntax:
Java.sql.Statement st=connection.createStatement();

RETREIVING VALUES FROM RESULT SET

 JDBC returns results in a ResultSet object, so we need to declare in
instance of the class ResultSet to hold our result. The following code demonstrates
declaring the ResultSet object RS and assigning the results to query:

ResultSet rs=st.executeQuery(“SELECT NAME FROM FACE”);

OVERVIEW OF SQL SERVER

DATABASE

A database is a set of data, organized for easy access. The database is

an actual data; it is the database that you will be accessing when you need to
retrieve data.

DATA DICTIONARY

The data dictionary is a set of tables SQL uses to maintain information

about the database. The data dictionary contains information about tables, indexes,
clusters and so on.

DBA (DATABASE ADMINISTRATOR)

The DBA is the person responsible for the operation, configuration and
performance of the database. The DBA is charged with keeping the database
operating smoothly, ensuring that backups are done on regular basis (and that
backups work), and installing new software. Other responsibilities might include
planning for future expansion and disk space needs, creating databases and table
spaces, adding users and maintaining security, and monitoring the database and
retuning it as necessary. Large installations might have teams of DBA’s to keep the
system running smoothly; alternatively, the task might be segmented among the
DBA’s.

STRUCTURED QUERY LANGUAGE (SQL)

SQL is an ANSI standard computer programming language used

to query relational databases. The ANSI standard for SQL specifies the
core syntax for language itself.

Create Table Command: This is used to create a table in database

specifying the columns in it.

Syntax: create table table_name (column_name datatype(size));

Insertion of values: This is used to insert values to the specified columns

in the table.

Syntax: insert into table_name values (expressions);

Viewing Data from tables: This is used to view the content’s of the table
created.
Syntax: select * from table_name;
Creating a table from existing table: This is used to create a table from
existing table by taking the columns needed.

Syntax: create table table_name[(column_name)] as select column_name

from table_name;

Inserting data into a table from another table: This is used to insert rows
from one table into another table.

Syntax : insert into table_name values select column_name from

table_name;

Delete operation: The verb DELETE in SQL is used to remove all rows
from table, or a selected set of rows from a table.

Syntax: delete from table_name; (deletes all rows)

Syntax: delete from table_name where condition; (deletes specified rows

based on condition)

Updating the contents of a table: the update command is used to change

or modify data values in a table. To update all the rows from table OR a
select set of rows from a table.

Syntax: update table_name set column_name = expression; (updates all

the rows)
Syntax: update table_name set column_name =expression where
condition; (updates selected rows based on condition)

Modifying existing columns: This is used in situation whenever we need

to change the type and size of the column.

Syntax: Alter table table_name modify (column_name new datatype (new size));

Renaming tables: To change the table name.

Syntax: rename oldtable_name to newtable_name;

Destroying tables: This is used to delete any table from the database.

Syntax: drop table_name;

Finding out the tables created by user: To display all the tables which
are there in our database.

Syntax: select * from tab;

Finding out the columns details of a table created: To check which

columns are present and what is there datatype& size we use this
command i.e. desc.

Syntax: desc table_name;

 4. SYSTEM DESIGN

4.1Normalization

Normalization is the process of strutting relational database schema such that most
ambiguity is removed. The stage of normalization are referred to as forms and
progress from the least restrictive(first normal form)through the most
restrictive(Fifth normal form), generally , most database designers do not attempt
to implement anything higher then normal form of Boyce code Normal Form.
FIRST NORMAL FORM:
A relation is said to be in First normal form (INF) if and each attributed of
the relation is atomic. More simply, to be INF, each column must contain only a
single value and each now contain in the same column.

SECOND NORMAL FORM:

In the Second normal Form, a relation must first fulfill the requirement to
be in first Normal Form. Additional, each donkey attribute in the relation must be
functionality dependent upon the primary key.

THIRD NORMAL FORM:

A table is said to be in third normal form and every non key attribute is
functionality dependent only on the primary key. This normalization process is
applied to this system and the normalized tables are given in the above section.
4.2TABLE DESIGN
Registration

4.3 INPUT DESIGN

Input Data type
name string
Gender String
phone no Numeric

Address Alpha numeric

image Image
4.4 SFD/DFD
SYSTEM ARCHITECTURE:

Segmentation Enhancement

Fingerprint

Identification
Fingerprint Minutia
Matching Extraction
DATA FLOW DIAGRAM:

Fingerprint Pre- Fingerprint Authentication

image processing extraction

Database

Level 0:
User id

Fingerprint images
Fingerprint Features database Enrollment Authentication

Fingerprint database
Level 1

Fingerprint images Fingerprint database

DB

Fingerprint Features
Level 2

Level 2

User
Level 1
fingerprint
Fingerprint Extraction Segmentation
Fingerprint feature DB

User fingerprint

Finger print Database

Level 3

User
fingerprint

Minutiae Extraction Matching

Enrollment Segmentation

Fingerprint database

Level 4

Userid

no
Authentication Determine or verify Match Not match

yes

Fingerprint database
Use case model:
 CLASS DIAGRAM

5. SYSTEM DESCRIPTION
Modules:

 Fingerprint database
 Fingerprint features database
 Enrollment Module
 Authentication module.

Module Description:

Fingerprint database:

Fingerprint database stored the user fingerprint images in the database

system. In this fingerprint database system used to feature database system.

Fingerprint features database:

Feature database system retrieves the fingerprint images from the database
and to create the user id for Enrollment module.

Enrollment Module:

The main objectives of Enrollment module is to admit the user his/her ID

and Fingerprints into the Fingerprint database after the process of Feature
extraction.

Authentication Module:

Authentication module is used to determine or verify the identity of the

fingerprint image or subject, formulating the process of authentication. The
component of the AFIS (Automatic Fingerprint Identification Systems) used for
authentication is referred to as the authentication
Module.
 6. TESTING AND IMPLEMENTATION

Testing is a process of executing a program with the indent of

finding an error. Testing is a crucial element of software quality assurance and
presents ultimate review of specification, design and coding.

System Testing is an important phase. Testing represents an interesting anomaly

for the software. Thus a series of testing are performed for the proposed system
before the system is ready for user acceptance testing.

A good test case is one that has a high probability of finding an as

undiscovered error. A successful test is one that uncovers an as undiscovered error.

Testing Objectives:

1. Testing is a process of executing a program with the intent of finding an error

2. A good test case is one that has a probability of finding an as yet undiscovered
error
3. A successful test is one that uncovers an undiscovered error

Testing Principles:

 All tests should be traceable to end user requirements

 Tests should be planned long before testing begins
 Testing should begin on a small scale and progress towards testing in large
 Exhaustive testing is not possible
 To be most effective testing should be conducted by a independent third party
 The primary objective for test case design is to derive a set of tests that has the
highest livelihood for uncovering defects in software. To accomplish this objective
two different categories of test case design techniques are used. They are

 White box testing.

 Black box testing.

White-box testing:

White box testing focus on the program control structure. Test cases are
derived to ensure that all statements in the program have been executed at least
once during testing and that all logical conditions have been executed.

Block-box testing:

Black box testing is designed to validate functional requirements without regard to

the internal workings of a program. Black box testing mainly focuses on the
information domain of the software, deriving test cases by partitioning input and
output in a manner that provides through test coverage. Incorrect and missing
functions, interface errors, errors in data structures, error in functional logic are the
errors falling in this category.

Testing strategies:

A strategy for software testing must accommodate low-level tests that are
necessary to verify that all small source code segment has been correctly
implemented as well as high-level tests that validate major system functions
against customer requirements.

Testing fundamentals:
 Testing is a process of executing program with the intent of finding error. A
good test case is one that has high probability of finding an undiscovered error. If
testing is conducted successfully it uncovers the errors in the software. Testing
cannot show the absence of defects, it can only show that software defects present.

Testing Information flow:

Information flow for testing flows the pattern. Two class of input provided
to test the process. The software configuration includes a software requirements
specification, a design specification and source code.

Test configuration includes test plan and test cases and test tools. Tests are
conducted and all the results are evaluated. That is test results are compared with
expected results. When erroneous data are uncovered, an error is implied and
debugging commences.

Unit testing:

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 modules. Using
the detailed design description as a guide, important paths are tested to uncover
errors within the boundary of the modules. These tests were carried out during the
programming stage itself. All units of ViennaSQL were successfully tested.

Integration testing:

Integration testing focuses on unit tested modules and build the program
structure that is dictated by the design phase.

System testing:
 System testing tests the integration of each module in the system. It also
tests to find discrepancies between the system and its original objective, current
specification and system documentation. The primary concern is the compatibility
of individual modules. Entire system is working properly or not will be tested here,
and specified path ODBC connection will correct or not, and giving output or not
are tested here these verifications and validations are done by giving input values
to the system and by comparing with expected output. Top-down testing
implementing here.

Acceptance Testing:

This testing is done to verify the readiness of the system for the implementation.
Acceptance testing begins when the system is complete. Its purpose is to provide
the end user with the confidence that the system is ready for use. It involves
planning and execution of functional tests, performance tests and stress tests in
order to demonstrate that the implemented system satisfies its requirements.

Tools to special importance during acceptance testing include:

Test coverage Analyzer – records the control paths followed for each test case.

Timing Analyzer – also called a profiler, reports the time spent in various regions
of the code are areas to concentrate on to improve system performance.

Coding standards – static analyzers and standard checkers are used to inspect code
for deviations from standards and guidelines.

Test Cases:
 Test cases are derived to ensure that all statements in the program have been
executed at least once during testing and that all logical conditions have been
executed.
Using White-Box testing methods, the software engineer can drive test cases that
 Guarantee that logical decisions on their true and false sides.
 Exercise all logical decisions on their true and false sides.
 Execute all loops at their boundaries and with in their operational bounds.
 Exercise internal data structure to assure their validity.
The test case specification for system testing has to be submitted for review before
system testing commences.

IMPLEMENTATION:
Implementation is the stage where the theoretical design is turned into a
working system. The most crucial stage in achieving a new successful system and
in giving confidence on the new system for the users that it will work efficiently
and effectively.

The system can be implemented only after thorough testing is done and if it is
found to work according to the specification.

It involves careful planning, investigation of the current system and its constraints
on implementation, design of methods to achieve the change over and an
evaluation of change over methods a part from planning. Two major tasks of
preparing the implementation are education and training of the users and testing of
the system.

The more complex the system being implemented, the more involved will be
the systems analysis and design effort required just for implementation.

The implementation phase comprises of several activities. The required

hardware and software acquisition is carried out. The system may require some
software to be developed. For this, programs are written and tested. The user then
changes over to his new fully tested system and the old system is discontinued.

7.CONCLUSION AND FUTURE SCOPE

The main benefit of this algorithm is its fast running speed. It improves the verification performance too.
The algorithm identifies the unrecoverable corrupted areas in the fingerprint and removes them from
further processing. This is an important aspect of the algorithm as the presence of these areas would prove
to be extremely harmful for the extraction of minutiae points. It helps in removing the spurious minutiae
too which may also prove to be harmful in matching fingerprints correctly.
 8. FORMS AND REPORTS

Initial form

The above screen is the initial of this project ,it shows the all menu available in this project
Admin Login

The above screen is the login page for admin; here you will give authorized input for username
and password after clicking login button
User registration

This page shows new user register fingerprint details into the registration form.
Selecting finger print

After registration user selects their finger print image from the folder.
Registration

After finger print image selection the user enters their details into the finger print registration
form.

Finger print load

This form shows the finger print minutie detection.
Segmentation

This form shows the finger print identification and verification (segmentation) result.
Feature extraction

This form shows the finger print identification and verification (Extraction) result.
Enhancement

This form shows the finger print identification and verification (Enhancement) result.
Finger print check

This page shows enter the finger print details for fingerprint verification.
After finger print verification the form shows the match or no match result. Here the page shows
no match result.

This form shows fingerprint user details.

 9. BIBILOGRAPHY

[1] Lin Hong, Yifei Wan and Anil Jain. Fingerprint Image Enhancement:
Algorithm and Performance Evaluation. East Lansing, Michigan.
[2] Fingerprint Minutiae Extraction, Department of Computer Science National
Tsing Hua University Hsinchu, Taiwan 30043
[3] Handbook of Fingerprint Recognition by David Maltoni (Editor), Dario Maio,
Anil K. Jain, Salil Prabhakar
[3] L. Hong, A. Jain, S. Pankanti and R. Bolle, Fingerprint Enhancement, Pattern
Recognition, 202-207, 1996
[4] A. K. Jain, L. Hong, S. Pantanki and R. Bolle, An Identity Authentication
System Using Fingerprints, Proc of the IEEE, vol, 85, no.9,1365-1388, 1997
Sample code:
import java.lang.*;
import java.io.*;
import java.util.*;
public class bruteforcefourway
{
public static void main(String args[ ])
{

String text1,pattern1;
Scanner s=new Scanner(System.in);
System.out.println("\n Enter the text");
text1=s.nextLine();
System.out.println("\n Enter the pattern");
pattern1=s.nextLine();
brute(text1,pattern1);
}

public static void brute(String text,String pattern)

{
int count=0,i,j;
int n=text.length(); // length of the text
int m=pattern.length(); //length of the pattern
for(i= 0;i<=n/2;i++)
{
j=0;
while((j<m)&&(pattern.charAt(j)==text.charAt(i + j)))
{
j++;
if (j==m)
{
 count++;
System.out.printf("\n %d Match found between %d and %d",count,i-1,i+m);
}
}
}
for(i= n/2+1;i<=n;i++)
{
j=0;
while((j<m)&&(pattern.charAt(j)==text.charAt(i + j)))
{
j++;
if (j==m)
{
count++;
System.out.printf("\n %d Match found between %d and %d",count,i-1,i+m);
}
}
}

for(i= n/2-m+1;i<=n/2+m-1;i++)// special case searching at the junction where splitting took
place
{
j=0;
while((j<m)&&(pattern.charAt(j)==text.charAt(i + j)))
{
j++;
if (j==m)
{
count++;
System.out.printf("\n %d Match found between %d and %d",count,i-1,i+m);
}
 }
}

System.out.printf("\n\n");
System.out.printf("\n Total Matches found are : %d",count);
}
}

public class StringConvenience {

public static void main(String[] args) {

String ptrn="1\\+1=2";

String text="1+1=2";
if(text.matches(ptrn)){
System.out.println(text+"\t"+ptrn);
}else{
System.out.println("no match");
}
}
}

public class Matching {

public static void main(String[] args) {

match("abc 888 rohini, NY 64332");
match("ABC 888 south ex, NY 64332-4453");
}
 public static boolean match(String address) {

boolean retrival = false;

String name = "\\p{Upper}";

String namePattern = "("+name +"){2,3}";

String zipCode = "\\d{5}(-\\d{4})?";

String regex = "^"+ namePattern + "\\w+ .*, \\w+ "

+ zipCode + "$";

retrival = address.matches(regex);

String msg = "NO MATCH\npattern:\n " + address + "\nregex is:\n "

+ regex;

if (retrival) {
msg = "MATCH\npattern:\n " + address + "\nregex is:\n "
+ regex;
}
System.out.println(msg + "\r\n");
return retrival;
}
}

import java.util.regex.*;
import java.io.*;
public class Print_matching_word {

public static void main(String[] args) throws Exception {

Pattern pattern = Pattern.compile("[0-9]+");
BufferedReader br = new BufferedReader
(new FileReader("/home/girish/Desktop/D.txt"));
String text;
System.out.println("Words with digit 1 to 9 are:");
while ((text = br.readLine()) != null) {
Matcher matcher = pattern.matcher(text);
while (matcher.find()) {
int start = matcher.start(0);
System.out.println(text.substring(start));
}
}
}
}

public class MyFeatureExtractor : FeatureExtractor<MyFeature>

{
public override MyFeature ExtractFeatures(Bitmap image)
{
// Place here your code to extract features
}
}

public class MyFeatureExtractor : FeatureExtractor<MyFeature>

{
public FeatureExtractor<List<Minutia>> MtiaExtractor { set; get; }
 public FeatureExtractor<OrientationImage> OrImgExtractor { set; get; }

public override MyFeature ExtractFeatures(Bitmap image)

{
try
{
var mtiae = MtiaExtractor.ExtractFeatures(image);
var orImg = OrImgExtractor.ExtractFeatures(image);
return ExtractFeatures(mtiae, orImg);
}
catch (Exception e)
{
if (MtiaExtractor == null)
throw new InvalidOperationException("Cannot extract MyFeature: Unassigned
minutia list extractor!", e);
if (OrImgExtractor == null)
throw new InvalidOperationException("Cannot extract MyFeature: Unassigned
orientation image extractor!", e);
throw;
}
}

public MyFeature ExtractFeatures(List<Minutia> mtiae, OrientationImage orImg)

{
// Place here your code to extract features
}
}

public class MyFeatureProvider : ResourceProvider<MyFeature>

{
 public MinutiaListProvider MtiaListProvider { get; set; }

public OrientationImageProvider OrImgProvider { get; set; }

public override string GetSignature()

{
return "myf";
}

public override bool IsResourcePersistent()

{
return true;
}

protected override MyFeature Extract(string fingerprint, ResourceRepository repository)

{
try
{
var mtiae = MtiaListProvider.GetResource(fingerprint, repository);
var orImg = OrImgProvider.GetResource(fingerprint, repository);
return featureExtractor.ExtractFeatures(mtiae, orImg);
}
catch (Exception e)
{
if (MtiaListProvider == null)
throw new InvalidOperationException("Unable to extract MyFeature: Unassigned
minutia list provider!", e);
if (OrImgProvider == null)
throw new InvalidOperationException("Unable to extract MyFeature: Unassigned
orientation image provider!", e);
throw;
 }
}

private MyFeatureExtractor featureExtractor = new MyFeatureExtractor();

}
public class MyMatcher : Matcher<MyFeature>
{
public override double Match(MyFeature query, MyFeature template)
{
// Place here your code to match fingerprints
}
}

public class MyMatcher : Matcher<MyFeature>, IMinutiaMatcher

{
public override double Match(MyFeature query, MyFeature template)
{
List<MinutiaPair> matchingMtiae;
return Match(query, template, out matchingMtiae);
}

public double Match(object query, object template, out List<MinutiaPair> matchingMtiae)

{
// Place here your code to match fingerprints
}
}