पायथन का उपयोग करके फिंगरप्रिंट पहचान विधियों और कार्यान्वयन

वर्तमान सेमेस्टर में, "कंप्यूटर की जानकारी की सुरक्षा के तरीके और साधन" अनुसूची में दिखाई दिए, जिनमें से एक भाग बायोमेट्रिक्स पर प्रयोगशाला का काम है, और विशेष रूप से फिंगरप्रिंट पहचान पर। इसके अलावा, हाल ही में, Habré पर स्कैनिंग के लिए इच्छित उपकरणों के बारे में एक लेख था। मैंने मान्यता एल्गोरिदम के बारे में यहां लिखने का फैसला किया।


मुझसे पहले, एक छात्र के रूप में, एक मानक कार्य है: एक फिंगरप्रिंट का सत्यापन (एक मानक के साथ तुलना)। चूंकि यह प्रयोगशाला केवल इस वर्ष दिखाई दी थी, इसलिए अभी तक इसके लिए कोई कार्यप्रणाली मैनुअल नहीं है। लेकिन टास्क की रोचकता को देखते हुए मैं गूगल में गया।

अजीब तरह से पर्याप्त है, लेख के दूसरे भाग में स्कैनर के विषय में संकेत दिया गया जो सबसे अधिक जानकारीपूर्ण निकला। यह वर्णन करता है, काफी समझ में आता है, कई एल्गोरिदम:

1. सहसंबंध तुलना
यह दृष्टिकोण अलग-अलग पारियों और रोटेशन कोणों के लिए दो छवियों की एक पिक्सेल-बाय-पिक्सेल तुलना में होता है, प्राप्त परिणामों के आधार पर, संयोग पर निर्णय किए जाते हैं। (आधुनिक परिस्थितियों में, उच्च जटिलता के कारण उपयोग नहीं किया जाता है)

2. पैटर्न की तुलना
आवश्यक सटीकता के आधार पर, प्रिंट की छवि क्षेत्रों में विभाजित है। इसके अलावा, प्रत्येक क्षेत्र में मापदंडों के साथ साइन लहर द्वारा वर्णित किया जाता है:

• प्रारंभिक चरण पारी
• तरंग दैर्ध्य
• वितरण की दिशा

एल्गोरिदम के इस वर्ग को स्कैन करते समय उच्च रिज़ॉल्यूशन की आवश्यकता नहीं होती है।

3. व्यक्ति अंकों से तुलना
फ़ीचर पॉइंट एंडपॉइंट और ब्रांच पॉइंट हैं। इन बिंदुओं को दोनों छवियों पर प्रकाश डाला गया है, और फिर सहसंबंध तुलना की विधि द्वारा, प्रिंट के पत्राचार पर एक निर्णय जारी किया जाता है।
इसकी अपेक्षाकृत सरल कार्यान्वयन और गति के कारण, ये एल्गोरिदम अधिक सामान्य हैं।
मैंने प्रयोगशाला में कार्यान्वयन के लिए इस प्रकार के एल्गोरिदम को चुना। इसलिए, हम इस पर अधिक विस्तार से ध्यान केंद्रित करते हैं।

चूंकि लेख ने केवल एक सामान्य विचार दिया, मैंने Google को जारी रखा। वितरण की तीसरी पंक्ति यह प्रस्तुति थी।
यह काफी कुछ विस्तार से वर्णन करता है कि चुने हुए दृष्टिकोण को लागू करने के लिए कदम।

तो, कार्य योजना:

• प्राप्त छवि का द्वैतकरण
• छवि कंकाल
• बिंदु चयन
• बिंदु तुलना

कार्यान्वयन पायथन में करने का निर्णय लिया गया। तदनुसार, खुद पाइथन के अलावा (मेरे पास संस्करण 2.7.1 है), मुझे छवि को पिक्सल में पार्स करने के लिए पीआईएल (पायथन इमेजिंग लाइब्रेरी) की आवश्यकता है।

चरण 1. द्विभाजन
तब मैंने आविष्कार नहीं किया, और सब कुछ काफी सरलता से किया, माथे में।

डीईएफ़ बाइनरी ( img ) :
bImg = [ ]
मैं सीमा में ( img। आकार [ 0 ] ) :
tmp = [ ]
j में सीमा के लिए ( img। आकार [ 1 ] ) :
t = img। getpixel ( ( i, j ) )
p = t [ 0 ] * 0.3 + t [ 1 ] * 0.59 + t [ 2 ] * 0.11
यदि p > 128 :
पी = 1
और :
पी = ०
tmp। परिशिष्ट ( पी )
bImg। परिशिष्ट ( tmp )
वापसी bImg

यदि आपको एक अलग परिणाम की आवश्यकता है, तो आपको "छवि प्रसंस्करण" ब्लॉग पर उन विषयों को देखना चाहिए, जहां द्विपार्षण काफी बार प्रभावित होता है।

चरण 2. कंकाल
यह कदम सबसे बड़ी कठिनाई का कारण बना, क्योंकि Google एल्गोरिदम सबसे कठिन थे। नतीजतन, 4 एल्गोरिदम पाए गए:

• टेम्प्लेट कंकालकरण ( टेम्प्लेट 1 का सेट , 2 सेट )
• वेव विधि ( अधिक )
• ज़ोंग-सन एल्गोरिथ्म ( अधिक )
• Schepin एल्गोरिथम

टेम्प्लेट विधि को चुना गया था, और पहला सेट, चूंकि, दूसरे सेट के टेम्प्लेट के विपरीत, इसे छवि के केवल एक क्रॉल की आवश्यकता होती है। सच है, अशुद्धि के स्तर को कम करने के लिए, दूसरे सेट से कुछ टेम्पलेट्स का उपयोग किया जाता है।

पैटर्न एक 3 * 3 मैट्रिक्स के अनुरूप हैं, जहां केंद्रीय तत्व छवि ट्रैवर्सल में वर्तमान पिक्सेल है।

यहाँ, ग्रे ऐसे पिक्सेल हैं जिनका रंग मायने नहीं रखता

पहले आठ टेम्पलेट मुख्य भाग हैं। "शोर" को खत्म करने के लिए नीचे से चार, और इन चारों को भी 90, 180 और 270 डिग्री घुमाया जा सकता है, और छवि के दूसरे बाईपास के लिए खोज की जाती है।

यदि हम एक टेम्पलेट में आते हैं, तो केंद्रीय पिक्सेल को सफेद रंग में रंगा जाता है (कंकाल का नहीं होता है)। हटाने के विकल्प बने रहते हुए ट्रैवर्सल जारी है।

इस क्रिया का कोड कई कार्यों में विभाजित है:

def tmpDelete ( img ) : # कंकालकरण प्रक्रिया की कॉल, इनपुट पर सूचियों की एक सूची (द्विपदिकरण के बाद)
w = लेन ( img )
h = len ( img [ 0 ] )
गिनती = १
जबकि गिनती ! = 0 : # रिपीट पोक कम से कम एक पिक्सेल हटा दिया गया था
गिनना = हटाना ( img, w, h )
यदि गणना:
Delete2 ( img, w, h )


डिफ डिलीट ( img, w, h ) : # मुख्य सेट से एक पिक्सेल हटाएं, हटाए गए की संख्या वापस करें
गिनती = ०
मैं सीमा में ( 1 , h- 1 ) :
j के लिए रेंज में ( 1 , w- 1 ) :
अगर img [ j ] [ i ] == 0 :
यदि हटाने योग्य ( img, j, i ) :
img [ j ] [ i ] = १
गिनती + = १
वापसी की गिनती

def delete2 ( img, w, h ) : # एक शोर सेट से एक पिक्सेल हटाएं
मैं सीमा में ( 1 , h- 1 ) :
j के लिए रेंज में ( 1 , w- 1 ) :
अगर img [ j ] [ i ] == 0 :
अगर हटाने योग्य 2 ( img, j, i ) :
img [ j ] [ i ] = १


def fringe ( a ) : # 3 * 3 शोर की परिभाषा
t = [ [ १ , १ , १ , १ , ० , १ , १ , १ , १ ] ,

[ १ , १ , १ , १ , ० , १ , १ , ० , ० ]
[ १ , १ , १ , ० , ० , १ , ० , १ , १ ] ,
[ 0 , 0 , 1 , 1 , 0 , 1 , 1 , 1 , 1 ] ,
[ १ , १ , ० , १ , ० , ० , १ , १ , १ ] ,

[ १ , १ , १ , १ , ० , १ , ० , ० , १ ] ,
[ 0 , 1 , 1 , 0 , 0 , 1 , 1 , 1 , 1 ] ,
[ 1 , 0 , 0 , 1 , 0 , 1 , 1 , 1 , 1 ] ,
[ 1 , 1 , 1 , 1 , 0 , 0 , 1 , 1 , 0 ] ,

[ १ , १ , १ , १ , ० , १ , ० , ० , ० ]
[ 0 , 1 , 1 , 0 , 0 , 1 , 0 , 1 , 1 ] ,
[ 0 , 0 , 0 , 1 , 0 , 1 , 1 , 1 , 1 ] ,
[ १ , १ , ० , १ , ० , ० , १ , १ , ० ] ]
मैं में टी के लिए:
यदि a == i:
सच लौटाओ

def check ( a ) : # यह निर्धारित करना कि 3 * 3 मुख्य टेम्प्लेट में से है या नहीं
t123457 = [ 1 , 1 , 0 , 0 , 1 , 0 ]
t013457 = [ 1 , 1 , 1 , 0 , 0 , 0 ]
t134567 = [ 0 , 1 , 0 , 0 , 1 , 1 ]
t134578 = [ 0 , 0 , 0 , 1 , 1 , 1 ]
t0123457 = [ 1 , 1 , 1 , 0 , 0 , 0 , 0 ]
t0134567 = [ 1 , 0 , 1 , 0 , 0 , 1 , 0 ]
t1345678 = [ 0 , 0 , 0 , 0 , 1 , 1 , 1 ]
t1234578 = [ 0 , 1 , 0 , 0 , 1 , 0 , 1 ]

t = [ a [ १ ] , [ २ ] , [ ३ ] , [ ४ ] , [ ५ ] , [ 1 ] ]
यदि t == t123457:
सच लौटाओ
t = [ एक [ ० ] , एक [ १ ] , एक [ ३ ] , एक [ ४ ] , एक [ ५ ] , एक [0 ] ]
यदि t == t013457:
सच लौटाओ
t = [ a [ १ ] , [ ३ ] , [ ४ ] , [ ५ ] , [ ६ ] , [ 1 ] ]
यदि t == t134567:
सच लौटाओ
t = [ a [ १ ] , [ ३ ] , [ ४ ] , [ ५ ] , [ , ] , [ 1 ] ]
यदि t == t134578:
सच लौटाओ
t = [ एक [ ० ] , एक [ १ ] , एक [ २ ] , एक [ ३ ] , एक [ ४ ] , एक [ ५ ] , एक [ ] ]]
यदि t == t0123457:
सच लौटाओ
t = [ a [ १ ] , [ ३ ] , [ ४ ] , [ ५ ] , [ ६ ] , [ 8 ] , [ ] ]]
यदि t == t1345678:
सच लौटाओ
t = [ एक [ ० ] , एक [ १ ] , एक [ ३ ] , एक [ ४ ] , एक [ ५ ] , एक [ ६ ] , एक [ ] ]]
यदि t == t0134567:
सच लौटाओ
t = [ a [ १ ] , [ २ ] , [ ३ ] , [ ४ ] , [ ५ ] , [ 8 ] , [ ] ]]
यदि t == t1234578:
सच लौटाओ

डिलीट करने योग्य ( img, x, y ) : # 3 प्राप्त करें 3, मुख्य के लिए सत्यापन के लिए सबमिट करें
a = [ ]
मैं सीमा में ( y- 1 , y + 2 ) :
j के लिए रेंज में ( x- 1 , x + 2 ) :
एक। append ( img [ j ] [ i ] )
रिटर्न चेक ( ए )

def deleteable2 ( img, x, y ) : # 3 3 प्राप्त करें, शोर के लिए चेक भेजें
a = [ ]
मैं सीमा में ( y- 1 , y + 2 ) :
j के लिए रेंज में ( x- 1 , x + 2 ) :
एक। append ( img [ j ] [ i ] )
रिटर्न फ्रिंज ( a )

चरण 3. विलक्षण बिंदुओं को हाइलाइट करें
यहां सब कुछ तुच्छ है। यदि 8 बिंदुओं के पड़ोस में, केवल एक काला है, तो यह अंतिम बिंदु है। यदि उनमें से 2 हैं तो यह केवल रेखा का बिंदु है। तीन एक शाखा बिंदु है।

def checkThisPoint ( img, x, y ) : # पड़ोस में काले रंग की गणना करें
ग = ०
i for रेंज ( x- 1 , x + 2 ) :
j के लिए रेंज में ( y- 1 , y + 2 ) :
अगर img [ i ] [ j ] == ० :
सी + = १
वापसी c- १

def FindCheckPoint ( img ) : # शाखा बिंदुओं और अंत की सूची बनाना
x = लेन ( img )
y = लेन ( img [ 0 ] )
ब्रांचप्वाइंट = [ ]
एंडपॉइंट = [ ]
i for रेंज ( x ) :
j के लिए रेंज में ( y ) :
अगर img [ i ] [ j ] == ० :
t = checkThisPoint ( img, i, j )
यदि t == 1 :
endpoint। परिशिष्ट ( i, j ) )
यदि t == 3 :
branchPoint। परिशिष्ट ( i, j ) )
वापसी ( ब्रांचपॉइंट, एंडपॉइंट )

एकमात्र समस्या शोर का पूर्ण उन्मूलन नहीं थी, जिसके कारण उन प्रक्रियाओं की उपस्थिति हुई, जिन्हें एकवचन बिंदु के रूप में मान्यता दी गई थी। उन्हें ध्यान में नहीं लेने के लिए, निकट खड़े (10 * 10) शाखा बिंदुओं और अंत बिंदुओं को हटा दिया गया था।

def __removeDouble ( x, y ) : # उन तत्वों की एक सूची देता है जिनके पास अन्य सूची में समान नहीं है
z = [ ]
मैं के लिए एक्स में:
ग = सच
जे में y के लिए:
अगर मैं == j:
ग = गलत
यदि ग:
जेड। परिशिष्ट ( i )
मैं में y के लिए:
ग = सच
जे के लिए एक्स में:
अगर मैं == j:
ग = गलत
यदि ग:
जेड। परिशिष्ट ( i )
वापसी Z

डीएलएनओइसेप्‍वाइंट ( आर ) को हराया: # इनपुट टपल (शाखा, अनुगामी)
tmp = [ ]
tmp2 = [ ]
i in r [ 1 ] के लिए :
x = सीमा ( i [ 0 ] - 5 , i [ 0 ] + 5 )
y = सीमा ( i [ 1 ] - 5 , i [ 1 ] + 5 )
j में r के लिए [ 0 ] :
अगर j [ 0 ] x और j [ 1 ] y में:
tmp। परिशिष्ट ( i )
tmp2। परिशिष्ट ( जे )
वापसी ( __removeDouble ( r [ 0 ] , tmp2 ) , __ removeDouble ( r [ 1 ] , tmp2 ) )

चरण 4. बिंदुओं की तुलना करें
एक बिंदु के लिए एक सरल खोज जो 30 * 30 के पड़ोस में प्रवेश करती है, उसी प्रकार का एक बिंदु है।

डीई मेलबॉइंट ( आर, वी ) : #input: संदर्भ बिंदुओं की जाँच और चेक किए गए के टपल; उत्पादन (मिलान, कुल)
सभी = ०
मैच = ०
i में v के लिए [ 0 ] :
x = सीमा ( i [ 0 ] - 15 , i [ 0 ] + 15 )
y = श्रेणी ( i [ १ ] - १५ , मैं [ १ ] + १५ )
सभी + = 1
j में r के लिए [ 0 ] :
अगर j [ 0 ] x और j [ 1 ] y में:
मैच + = १
ब्रेक
i में v के लिए [ 1 ] :
x = सीमा ( i [ 0 ] - 15 , i [ 0 ] + 15 )
y = श्रेणी ( i [ १ ] - १५ , मैं [ १ ] + १५ )
सभी + = 1
j में r के लिए [ 1 ] :
अगर j [ 0 ] x और j [ 1 ] y में:
मैच + = १
ब्रेक

वापसी ( मैच, सब )

इसके अलावा:
सभी कोड एक ही आकार की छवियों के लिए मान्य हैं (हालांकि यह अलग-अलग लोगों पर काम करेगा)।

निष्कर्ष:
1. यह कार्यान्वयन सरल और अनाड़ी है। कुछ चेक के साथ इसे पूरक करना संभव है, उदाहरण के लिए, विशेष बिंदुओं पर लाइनों के कोणों को देखें। जाँच करते समय, पहले से ही पाए गए जोड़े को त्यागने के लिए, उन मामलों के लिए जब एक ही प्रकार के कई बिंदु पड़ोस में आते हैं।
2. पायथन में कार्यान्वयन बल्कि धीमी गति से है: मेरी मशीन पर निष्पादन की गति बहुत अधिक मानव यातायात वाले आइटमों के लिए पूरी तरह से अनुपयुक्त है। यह संभव है कि NumPy का उपयोग करने से प्रदर्शन में सुधार होगा, और मैं सबसे अच्छा कार्यान्वयनकर्ता भी नहीं हूं।
3. यहां पूरा कोड लें। इस किट पर परीक्षण किया गया।

पी एस मैं कोड पर टिप्पणी करना चाहूंगा, जैसा कि अजगर में मैं कमजोर रूप से उन्मुख करता हूं। खैर, उन लोगों की राय जो गंभीरता से फिंगरप्रिंटिंग में लगे हुए हैं।