This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Table of Contents1. Introduction.........................................................................................................................................2
This matrix will be of size N by N, where N is the total number of face images. Each entry in the
column will then represent the corresponding weight of that particular image with respect to a
particular eigenvector.
2. Project into "face space" by a simple operation, this operation is same as defined above. But
here we are projecting a single image and hence we will get a matrix of size N [rows] by 1
[columns].Let's call this matrix as 'TestProjection' matrix.
for k=1,2.....N. Where N is the total number of training images.
3. Find the distance between the each element of the testProjection matrix and the corresponding
element of Weight matrix. We will get a new matrix of N [rows] by N [columns].
4. Find the 2-Norm for the above derived matrix. This will be a matrix of 1 [rows] by N
[columns]. Find the minimum value for all the column values. If it is with in some threshold
value then return that column number. That number represents the image number. That number
shows that the test image is nearest to that particular image from the set of training images. If the
minimum value is above the threshold value, then that test image can be considered as a new
image which is not in our training image set. And that can be stored in our training image set by
applying the same procedure [mentioned in section 5.2]. So the system is a kind of learning
system which automatically increases its knowledge if it encounters some unknown image [ the 1
which it couldn't detect ].
5. Testing
Introduction
Software testing is a critical element of software quality assurance and represents the ultimate
service of specification design and coding. The increasing visibility of software as a system
element and the attended costs associated with the software failure and motivating forces for well
planned, thorough testing. It is not unusual for a software development to spend between 30 and
40 percent of total project effort in testing. System Testing Strategies for this system integrate
test case design techniques into a well planned series of steps that result in the successful
construction of this software. It also provides a road map for the developer, the quality assurance
organization and the customer, a roadmap that describes the steps to be conducted as path of
testing, when these steps are planned and then undertaken and how much effort, time and
resources will be required.
The test provisions are follows.
System testing
Software Testing: As the coding is completed according to the requirement we have to test the
quality of the software. Software testing is a critical element of software quality assurance and
represents the ultimate review of specification, design and coding. Although testing is to uncover
the errors in the software but it also demonstrates that software functions appear to be working as
per the specifications, those performance requirements appear to have been met. In addition, data
collected as testing is conducted provide a good indication of software and some indications of
software quality as a whole. To assure the software quality we conduct both White Box Testing
and Black Box Testing.
White Box Testing:
White Box Testing is a test case design method that uses the control structure of the
procedural design to derive test cases. As we are using a non-procedural language, there is very
small scope for the White Box Testing. Whenever it is necessary, there the control structure are
tested and successfully passed all the control structure with a very minimum error.
Black Box Testing:
Black Box Testing focuses on the functional requirement of the software. It enables to
derive sets of input conditions that will fully exercise all functional requirements for a program.
The Black Box Testing finds almost all errors. If finds some interface errors and errors in
accessing the database and some performance errors. In Black Box Testing we use mainly two
techniques Equivalence partitioning the Boundary Volume Analysis Technique.
Equivalence Partitions:
In the method we divide input domain of a program into classes of data from which test cases are
derived. An Equivalence class represents a set of valid or invalid of a set of related values or a
Boolean condition.
The equivalence for these is: Input condition requires specific value-specific or non-specific two
classes.
Input condition requires a range or out of range two classes.
Input condition specifies a number of a set-belongs to a set or not belongs to the set two classes.
Input condition is Boolean-valid or invalid Boolean condition two classes.
Boundary Values Analysis:
Number of errors usually occurs at the boundaries of the input domain generally. In this
technique a selection of test cases is exercised using boundary values i.e., around boundaries. By
the above two techniques, we eliminated almost all errors from the software and checked for
numerous test values for each and every input value. The results were satisfactory. Flow of
Testing System testing is designated to uncover weakness that was not detected in the earlier
tests. The total system is tested for recovery and fallback after various major failures to ensure
that no data are lost. An accepted test is done to validity and reliability of the system. The
philosophy behind the testing is to find error in project.
There are many test cases designed with this is mind. The flow of testing is as follows.
Code Testing
Specification testing is done to check if the program does with it should do and how it should
behave under various conditions or combinations and submitted for processing in the system and
it’s checked if any overlaps occur during the processing. This strategy examines the logic of the
program. Here only syntax of the code is tested. In code testing syntax errors are corrected, to
ensure that the code is perfect.
Unit Testing:
The first level of testing is called unit testing. Here different modules are tested against the
specifications produced during the design of the modules. Unit testing is done to test the working
of individual modules with test oracles. Unit testing comprises a set of tests preformed by an
individual programmer prior to integration of the units into a large system. A program unit is
small enough that the programmer who developed if can test it in a great detail. Unit testing
focuses first on the modules to locate errors. These errors are verified and corrected so that the
unit perfectly fits to the project.
System Testing
The next level of testing is system testing and acceptance testing. This testing is done to check if
the system has its requirements and to find the external behavior of the system. System testing
involves two kinds of activities:
Integration testing
Acceptance testing
Integration Testing
The next level of testing is called the Integration Testing. In this many tested modules are
combined into subsystems, which were tested. Test case data is prepared to check the control
flow of all the modules and to exhaust all possible inputs to the program. Situations like treating
the modules when there is no data entered in the text box is also tested. This testing strategy
dictates the order in which modules must be available, and exerts strong influence on the order in
which the modules must be written, debugged and unit tested. In integration testing, all the
modules / units on which unit testing is performed are integrated together and tested.
Acceptance Testing:
This testing is performed finally by user to demonstrate that the implemented system satisfies its
requirements. The user gives various inputs to get required outputs.
Specification Testing:
Specification testing is done to check if the program does what is should do and how it should
behave under various conditions or combination and submitted for processing in the system and
it is checked if any overlaps occur during the processing.
Testing Objectives:
The following are the testing objectives….
Testing is a process of executing a program with the intent of finding an error.
A good test case is one that has a high probability of finding an as yet undiscovered error.
A successful test is one that uncovers an as yet undiscovered error.
The above objectives imply a dramatic change in view point. They move counter to the
commonly held view that a successful test is one in which no errors are found. Our objective is
to design tests that systematically verify different clauses of errors and do so with minimum
amount of time and effort. If testing is conducted successfully, it will uncover errors in the
software. As a secondary benefit, testing demonstrates that software functions appear to be
working according to specification and that performance requirements appear to have been met.
In addition, data collected as testing is conducted provides a good indication of software. Testing
can’t show the absence of defects, it can only show that software errors are present. It is
important to keep this stated in mind as testing is being conducted.
Testing principles:
Before applying methods to design effective test cases, a software engineer must
understand the basic principles that guide software testing.
• All tests should be traceable to customer requirements.
• Tests should be planned long before testing begins.
• Testing should begin “in the small” and progress towards testing “in the large”.
• Exhaustive testing is not possible.
Test Plan:
A test plan is a document that contains a complete set of test cases for a system, along
with other information about the testing process. The test plan should be returned long before the
testing starts.
Test plan identifies
1. A task set to be applied as testing commences,
2. The work products to be produced as each testing task is executed
3. The manner, in which the results of testing are evaluated, recorded and reuse when regression
testing is conducted. In some cases the test plan is indicated with the project plan. In others the
test plan is a separate document. The test report is a record of the testing performed. The testing
report enables the acquirer to assess the testing and its results. The test report is a record of the
testing performed. The testing report enables the acquirer to assess the testing and its results.
Test cases
Test cases for login page
Sl no
Task Expected result Obtained result Remarks
1 Using valid username
and
password(Image)
Successful
authentication
As expected success
2 Using invalid
username
Authentication
failed
As expected Invalid user
name
3 Using invalid
password(Image)
Authentication
failed
As expected Username and
password are
not correct
4 Without giving
username and
password
Authentication
failed As expected
Please enter
user name and
password
5 Username and
without password
Authentication
failed
As expected Password
cannot be
empty
Test cases for registration page
Sl no Task Expected result Obtained
result
Remarks
1 Capture four images Registration As expected success
and register success
2 Capture three
images and register
Should not allow
to register
As expected
Register button is
disabled if less than
four images are
captured.
3 Without giving port
number
Connection failed As expected Please specify port
number
4 Without selecting IP Connection failed As expected Ip has to be selected
6. Snapshots
Layout
The layout contains two sections. Left section is used for placing web camera window. Right section is used to show capture images for login and registration.
Web camera Window
This is a separate window which is created using separate thread.
Register Window
Four images are shown which are captured during registration.
Login Screen
The image is captured for login is shown in this window. Success message is shown as below.
Login screen ( login failure).
Login Screen and Web camera
Web camera and captured image during login is as shown below.
7. Conclusion
1. The user will be authenticated not only with the username also with the image of the user
2. For the processing, some of the lines on the face will be used so that the image can be identified with the different angles.
3. The image processing process is good enough to provide security for the website.
8. Future Enhancements
1. The project can be enhanced for processing 3D images.
2. Authentication can be implemented by capturing video clip of a person.
3. This can also be used to process the signatures of a person for providing the authentication.
4. We can also use this in real time application.
5. Authentication can be embedded into web application which will be an added advantage for providing the login for the websites.