Skip to main content

An Efficient Parallel Approach for Sclera Vein Recognition

Abstract:

Sclera vein recognition is shown to be a promising method for human identification. However, its matching speed is slow, which could impact its application for real-time applications. To improve the matching efficiency, we proposed a new parallel sclera vein recognition method using a two-stage parallel approach for registration and matching. First, we designed a rotation- and scale-invariant Y shape descriptor based feature extraction method to efficiently eliminate most unlikely matches. Second, we developed a weighted polar line sclera descriptor structure to incorporate mask information to reduce GPU memory cost. Third, we designed a coarse-to-fine two-stage matching method. Finally, we developed a mapping scheme to map the subtasks to GPU processing units. The experimental results show that our proposed method can achieve dramatic processing speed improvement without compromising the recognition accuracy.


INTRODUCTION 

THE sclera is the opaque and white outer layer of the eye. The blood vessel structure of sclera is formed randomly and is unique to each person , which can be used for human’s identification . Several researchers have designed different Sclera vein recognition methods and have shown that it is promising to use Sclera vein recognition for human identification. 

In [4], Crihalmeanu and Ross proposed three approaches: Speed Up Robust Features (SURF)-based method, minutiae detection, and direct correlation matching for feature registration and matching. Within these three methods, the SURF method achieves the best accuracy. It takes an average of 1.5 seconds1 using the SURF method to per form a one-to-one matching. In [3], Zhou et. al. proposed line descriptor-based method for sclera vein recognition. The matching step (including registration) is the most timeconsuming step in this sclera vein recognition system, which costs about 1.2 seconds to perform a one-to-one matching. Both speed was calculated using a PC with Intel® Core™ 2 Duo 2.4GHz processors and 4 GB DRAM. Currently, Sclera vein recognition algorithms [3, 4] are designed using central processing unit (CPU)-based systems. 

As discussed in [7], CPU-based systems are designed as sequential processing devices, which may not be efficient in data processing where the data can be parallelized. Because of large time consumption in the matching step, Sclera vein recognition using sequential-based method would be very challenging to be implemented in a real time biometric system, especially when there is large number of templates in the database for matching. GPUs (as abbreviation of General purpose Graphics Processing Units: GPGPUs) are now popularly used for parallel computing to improve the computational processing speed and efficiency [8-20]. 

The highly parallel structure of GPUs makes them more effective than CPUs for data processing where processing can be performed in parallel. GPUs have been widely used in biometrics recognition such as: speech recognition [8], text detection [9], handwriting recognition [10], and face recognition [14]. In iris recognition [15], GPU was used to extract the features, construct descriptors, and match templates. GPUs are also used for object retrieval and image search [16-19]. Park et al. [20] designed the performance evaluation of image processing algorithms, such as linear feature extraction and multi-view stereo matching, on GPUs. However, these approaches were designed for their specific biometric recognition applications and feature searching methods. 


Therefore they may not be efficient for Sclera vein recognition. Compute Unified Device Architecture (CUDA), the computing engine of NVIDIA GPUs, is used in this research. CUDA is a highly parallel, multithreaded, many-core processor with tremendous computational power [21]. 

It supports not only a traditional graphics pipeline but also computation on non-graphical data. More importantly, it offers an easier programming platform which outperforms its CPU counterparts in terms of peak arithmetic intensity and memory bandwidth [22]. 

In this research, the goal is not to develop a unified strategy to parallelize all sclera matching methods because each method is quite different from one another and would need customized design. To develop an efficient parallel computing scheme, it would need different strategies for different

Comments

Popular posts from this blog

Inverted Linear Quadtree: Efficient Top K Spatial Keyword Search

Inverted Linear Quadtree: Efficient Top K Spatial Keyword Search ABSTRACT: In this paper, With advances in geo-positioning technologies and geo-location services, there are a rapidly growing amount of spatiotextual objects collected in many applications such as location based services and social networks, in which an object is described by its spatial location and a set of keywords (terms). Consequently, the study of spatial keyword search which explores both location and textual description of the objects has attracted great attention from the commercial organizations and research communities. In the paper, we study two fundamental problems in the spatial keyword queries: top k spatial keyword search (TOPK-SK), and batch top k spatial keyword search (BTOPK-SK). Given a set of spatio-textual objects, a query location and a set of query keywords, the TOPK-SK retrieves the closest k objects each of which contains all keywords in the query. BTOPK-SK is the batch processing of sets...

A simple and reliable touch sensitive security system CODING

#include <REGX51.H> #include "lcd.c" #define MAX_DELAY() delay(65000) sbit Vibra_Sense=P3^1; sbit Buz=P1^0; void intro() {  lcd_init();  lcd_str("Touch Sensitive ",0x80);  lcd_str("Security System ",0xc0);  MAX_DELAY();MAX_DELAY();  lcd_clr();  }  void main()  { unsigned int i = 0, j= 0; intro();    while(1)    { lcd_str("Security Syst On",0x80); lcd_str("No Vibra Detectd",0xc0); Buz = 1; if(Vibra_Sense == 1) { while(Vibra_Sense == 1) delay(1000); } else { while(Vibra_Sense == 0) delay(1000); } Buz = 0; lcd_str("Vibraton Detectd",0xc0);delay(65000); while(1);    }  }

A Time Efficient Approach for Detecting Errors in Big Sensor Data on Cloud

A Time Efficient Approach for Detecting Errors in Big Sensor Data on Cloud Abstract                                                                                                                                                      ...