diff --git a/Iris-Recognition-master/Iris-Recognition-master/FeatureExtraction.py b/Iris-Recognition-master/Iris-Recognition-master/FeatureExtraction.py
new file mode 100644
index 0000000..6c1732d
--- /dev/null
+++ b/Iris-Recognition-master/Iris-Recognition-master/FeatureExtraction.py
@@ -0,0 +1,84 @@
+import cv2
+import numpy as np
+import glob
+import math
+import scipy
+from scipy.spatial import distance
+from scipy import signal
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn import metrics
+
+
+#modulating function as defined in paper
+def m(x ,y, f):
+    val = np.cos(2*np.pi*f*math.sqrt(x **2 + y**2))
+    return val
+#spatial filter as defined in paper
+def gabor(x, y, dx, dy, f):
+    gb = (1/(2*math.pi*dx*dy))*np.exp(-0.5*(x**2 / dx**2 + y**2 / dy**2)) * m(x, y, f)
+    return gb
+
+#function to calculate spatial filter over 8x8 blocks
+def spatial(f,dx,dy):
+    sfilter=np.zeros((8,8))
+    for i in range(8):
+        for j in range(8):
+            sfilter[i,j]=gabor((-4+j),(-4+i),dx,dy,f)
+    return sfilter
+
+def get_vec(convolvedtrain1,convolvedtrain2):
+    feature_vec=[]
+    for i in range(6):
+            for j in range(64):
+                #Run 8 by 8 filtered block iteratively over the entire image
+                start_height = i*8
+                end_height = start_height+8
+                start_wid = j*8
+                end_wid = start_wid+8
+                grid1 = convolvedtrain1[start_height:end_height, start_wid:end_wid]
+                grid2 = convolvedtrain2[start_height:end_height, start_wid:end_wid]
+
+                # Channel 1
+                absolute = np.absolute(grid1)
+                # mean
+                mean = np.mean(absolute)
+                feature_vec.append(mean)
+                #deviation
+                std = np.mean(np.absolute(absolute-mean))
+                feature_vec.append(std)
+
+                # Channel 2
+                absolute = np.absolute(grid2)
+                # mean
+                mean = np.mean(absolute)
+                feature_vec.append(mean)
+                #deviation
+                std = np.mean(np.absolute(absolute-mean))
+                feature_vec.append(std)
+
+    return feature_vec
+
+def FeatureExtraction(enhanced):
+    con1=[]
+    con2=[]
+    #get spatial filters
+    filter1=spatial(0.67,3,1.5)
+    filter2=spatial(0.67,4,1.5) 
+    
+    feature_vector=[]
+    
+    for i in range(len(enhanced)):
+        img=enhanced[i]
+        #define a 48x512 region over which the filters are applied
+        img_roi=img[:48,:]
+        
+        filtered1=scipy.signal.convolve2d(img_roi,filter1,mode='same')
+        filtered2=scipy.signal.convolve2d(img_roi,filter2,mode='same')
+        
+        con1.append(filtered1)
+        con2.append(filtered2)
+        fv=get_vec(filtered1,filtered2)
+        feature_vector.append(fv)
+    return feature_vector #each feature vector has a dimension of 1536
\ No newline at end of file
diff --git a/Iris-Recognition-master/Iris-Recognition-master/ImageEnhancement.py b/Iris-Recognition-master/Iris-Recognition-master/ImageEnhancement.py
new file mode 100644
index 0000000..1bdb54e
--- /dev/null
+++ b/Iris-Recognition-master/Iris-Recognition-master/ImageEnhancement.py
@@ -0,0 +1,21 @@
+
+# coding: utf-8
+
+import cv2
+import numpy as np
+import glob
+import math
+from scipy.spatial import distance
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn import metrics
+
+#Equalizes the histogram of the image
+def ImageEnhancement(normalized):
+    enhanced=[]
+    for res in normalized:
+        res = res.astype(np.uint8)
+        im=cv2.equalizeHist(res)
+        enhanced.append(im)
+    return enhanced
\ No newline at end of file
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/Fig1.png b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig1.png
new file mode 100644
index 0000000..4cc5824
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig1.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/Fig2.png b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig2.png
new file mode 100644
index 0000000..fcc9aac
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig2.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/Fig3.png b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig3.png
new file mode 100644
index 0000000..d5a0bfe
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig3.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/Fig4.png b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig4.png
new file mode 100644
index 0000000..f7877ed
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig4.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/Fig5.png b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig5.png
new file mode 100644
index 0000000..e95ac02
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig5.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/Fig6.png b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig6.png
new file mode 100644
index 0000000..3fc5a1c
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig6.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/Fig7.png b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig7.png
new file mode 100644
index 0000000..92ac343
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig7.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/Fig8.png b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig8.png
new file mode 100644
index 0000000..40ddab6
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/Fig8.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/code1.png b/Iris-Recognition-master/Iris-Recognition-master/Images/code1.png
new file mode 100644
index 0000000..4a810e7
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/code1.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/code2.png b/Iris-Recognition-master/Iris-Recognition-master/Images/code2.png
new file mode 100644
index 0000000..07bc343
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/code2.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/Images/code3.png b/Iris-Recognition-master/Iris-Recognition-master/Images/code3.png
new file mode 100644
index 0000000..b857264
Binary files /dev/null and b/Iris-Recognition-master/Iris-Recognition-master/Images/code3.png differ
diff --git a/Iris-Recognition-master/Iris-Recognition-master/IrisLocalization.py b/Iris-Recognition-master/Iris-Recognition-master/IrisLocalization.py
new file mode 100644
index 0000000..c6cabf9
--- /dev/null
+++ b/Iris-Recognition-master/Iris-Recognition-master/IrisLocalization.py
@@ -0,0 +1,76 @@
+
+# coding: utf-8
+
+import cv2
+import numpy as np
+import glob
+import math
+from scipy.spatial import distance
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn import metrics
+
+def IrisLocalization(images):
+    #convert image to a color image
+    target = [cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for img in images]
+    boundary=[] #initialize empty list that will eventually contain all the images with boundaries
+    centers=[] #initialize empty list that will contain the centers of the boundary circles
+    for img in target:
+        
+        draw_img=img
+        
+        # remove noise by blurring the image
+        blur = cv2.bilateralFilter(img, 9,75,75)
+        img=blur
+        
+        #estimate the center of pupil
+        horizontalProjection = np.mean(img,0);
+        verticalProjection = np.mean(img,1);
+        center_x=horizontalProjection.argmin()
+        center_y=verticalProjection.argmin()
+        
+        #recalculate of pupil by concentrating on a 120X120 area
+        centrecrop_x = img[center_x-60:center_x+60]
+        centrecrop_y = img[center_y-60:center_y+60]
+        horizontalProjection = np.mean(centrecrop_y,0);
+        verticalProjection = np.mean(centrecrop_x,0);
+        crop_center_x=horizontalProjection.argmin()
+        crop_center_y=verticalProjection.argmin()
+
+        cimg=img.copy()
+        cv2.circle(cimg,(crop_center_x,crop_center_y),1,(255,0,0),2)
+
+        #apply Canny edge detector on the masked image
+        maskimage = cv2.inRange(img, 0, 70)
+        output = cv2.bitwise_and(img, maskimage)
+        edged = cv2.Canny(output, 100, 220)
+        
+        # Apply Hough transform to find potential boundaries of pupil
+        circles = cv2.HoughCircles(edged, cv2.HOUGH_GRADIENT, 10, 100)
+        
+        #define the center of the pupil
+        a = (crop_center_x,crop_center_y)
+        
+        out = img.copy()
+        min_dst=math.inf
+        for i in circles[0]:
+            #find the circle whose center is closest to the approx center found above
+            b=(i[0],i[1])
+            dst = distance.euclidean(a, b)
+            if dst<min_dst:
+                min_dst=dst
+                k=i
+                
+        #draw the inner boundary
+        cv2.circle(draw_img, (k[0], k[1]), k[2], (255, 0, 0), 3)
+
+        pupil=circles[0][0]
+        radius_pupil = int(k[2])
+        
+        #draw the outer boundary, which is approximately found to be at a distance 53 from the inner boundary 
+        cv2.circle(draw_img, (k[0], k[1]), radius_pupil+53, (255, 0, 0), 3)
+        boundary.append(draw_img)
+        centers.append([k[0],k[1],k[2]])
+    return boundary,centers
+
diff --git a/Iris-Recognition-master/Iris-Recognition-master/IrisMatching.py b/Iris-Recognition-master/Iris-Recognition-master/IrisMatching.py
new file mode 100644
index 0000000..f451244
--- /dev/null
+++ b/Iris-Recognition-master/Iris-Recognition-master/IrisMatching.py
@@ -0,0 +1,152 @@
+# coding: utf-8
+
+import cv2
+import numpy as np
+import glob
+import math
+from scipy.spatial import distance
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn import metrics
+
+def dim_reduction(feature_vector_train,feature_vector_test,components):
+    '''TRAINING'''
+    ft_train=feature_vector_train
+    
+    #get the classes of all training feature vectors
+    y_train=[]
+    for i in range(0,108):
+        for k in range(0,3):
+            y_train.append(i+1)
+    y_train=np.array(y_train)
+    
+    #fit the LDA model on training data with n components
+    sklearn_lda = LDA(n_components=components)
+    sklearn_lda.fit(ft_train,y_train)
+    
+    #transform the traning data
+    red_train=sklearn_lda.transform(ft_train)
+    
+    '''TESTING'''
+    ft_test=feature_vector_test
+    
+    #transform the testing data
+    red_test=sklearn_lda.transform(ft_test)
+    
+    
+    #get a list of predicted values for the testing data to calculate ROC
+    y_pred=sklearn_lda.predict(ft_test)
+    
+    #return transformed training and testing data, and the testing classes and predicted values for ROC
+    return red_train,red_test
+
+
+def IrisMatching(feature_vector_train,feature_vector_test,components,flag):
+    
+    #if flag is 1, we do not need to reduce dimesionality otherwise we call the dim_reduction function
+    if flag==1:
+        red_train=feature_vector_train
+        red_test=feature_vector_test
+        
+    elif flag==0:
+        red_train,red_test=dim_reduction(feature_vector_train,feature_vector_test,components)
+
+
+    arr_f=red_test #test
+    arr_fi=red_train #train
+    
+    index_L1=[]
+    index_L2=[]
+    index_cosine=[]
+    min_cosine=[]
+    
+    #this loop iterates over each test image
+    for i in range(0,len(arr_f)):
+        L1=[]
+        L2=[]
+        Cosine=[]
+        
+        #this loop iterates over every training image - to be compared to each test image
+        for j in range(0,len(arr_fi)):
+            f=arr_f[i]
+            fi=arr_fi[j]
+            sumL1=0 #L1 distance
+            sumL2=0 #L2 distance
+            sumcos1=0
+            sumcos2=0
+            cosinedist=0 #cosine distance
+            
+            #calculate L1 and L2 using the formulas in the paper
+            for l in range(0,len(f)):
+                sumL1+=abs(f[l]-fi[l])
+                sumL2+=math.pow((f[l]-fi[l]),2)
+            
+            
+            #calculate sum of squares of all features for cosine distance
+            for k in range(0,len(f)):
+                sumcos1+=math.pow(f[k],2)
+                sumcos2+=math.pow(fi[k],2)
+                
+            
+            #calculate cosine distance using sumcos1 and sumcos2 calculated above
+            cosinedist=1-((np.matmul(np.transpose(f),fi))/(math.pow(sumcos1,0.5)*math.pow(sumcos2,0.5)))
+            
+            L1.append(sumL1)
+            L2.append(sumL2)
+            Cosine.append(cosinedist)
+        #get minimum values for L1 L2 and cosine distance for each test image and store their index
+        index_L1.append(L1.index(min(L1)))
+        index_L2.append(L2.index(min(L2)))
+        index_cosine.append(Cosine.index(min(Cosine)))
+        min_cosine.append(min(Cosine))
+        
+    match=0
+    count=0
+    
+    #stores final matching - correct(1) or incorrect (0)
+    match_L1=[]
+    match_L2=[]
+    match_cosine=[]
+    match_cosine_ROC=[]
+    
+    #calculating matching of the test set according to the ROC thresholds
+    thresh=[0.4,0.5,0.6]
+    
+    for x in range(0,len(thresh)):
+        match_ROC=[]
+        for y in range(0,len(min_cosine)):
+            if min_cosine[y]<=thresh[x]:
+                match_ROC.append(1)
+            else:
+                match_ROC.append(0)
+        match_cosine_ROC.append(match_ROC)
+        
+    
+    for k in range(0,len(index_L1)):
+        '''count goes from 0 to 3 because we compare the indexes obtained for the first 4 images of the test data
+        to the indexes of the first 3 images of 
+        the train data (for which match is incremented by 3 everytime count exceeds the value of 3)'''
+        if count<4:
+            count+=1
+        else:
+            match+=3
+            count=1
+            
+        '''check if matching is done correctly (1) or not (0) for L1 L2 and cosine distance and accordingly update
+        the arrays match_L1,match_L2,match_cosine'''
+        if index_L1[k] in range(match,match+3):
+                match_L1.append(1)
+        else:
+            match_L1.append(0)
+        if index_L2[k] in range(match,match+3):
+            match_L2.append(1)
+        else:
+            match_L2.append(0)
+        if index_cosine[k] in range(match,match+3):
+            match_cosine.append(1)
+        else:
+            match_cosine.append(0)
+    #reuturns the matching arrays, and test calsses and predicted values to calculate ROC
+    return match_L1,match_L2,match_cosine,match_cosine_ROC
+
diff --git a/Iris-Recognition-master/Iris-Recognition-master/IrisNormalization.py b/Iris-Recognition-master/Iris-Recognition-master/IrisNormalization.py
new file mode 100644
index 0000000..b2d3d49
--- /dev/null
+++ b/Iris-Recognition-master/Iris-Recognition-master/IrisNormalization.py
@@ -0,0 +1,45 @@
+
+# coding: utf-8
+import cv2
+import numpy as np
+import glob
+import math
+from scipy.spatial import distance
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn import metrics
+
+def IrisNormalization(boundary,centers):
+    target = [img for img in boundary]
+    normalized=[]
+    cent=0
+    for img in target:
+        #load pupil centers and radius of inner circles
+        center_x = centers[cent][0]
+        center_y = centers[cent][1]
+        radius_pupil=int(centers[cent][2])
+        
+        iris_radius = 53 # width of space between inner and outer boundary
+    
+        #define equally spaced interval to iterate over
+        nsamples = 360
+        samples = np.linspace(0,2*np.pi, nsamples)[:-1]
+        polar = np.zeros((iris_radius, nsamples))
+        for r in range(iris_radius):
+            for theta in samples:
+                #get x and y for values on inner boundary
+                x = (r+radius_pupil)*np.cos(theta)+center_x
+                y = (r+radius_pupil)*np.sin(theta)+center_y
+                x=int(x)
+                y=int(y)
+                try:
+                #convert coordinates
+                    polar[r][int((theta*nsamples)/(2*np.pi))] = img[y][x]
+                except IndexError: #ignores values which lie out of bounds
+                    pass
+                continue
+        res = cv2.resize(polar,(512,64))
+        normalized.append(res)
+        cent+=1
+    return normalized #returns a list of 64x512 normalized images
\ No newline at end of file
diff --git a/Iris-Recognition-master/Iris-Recognition-master/IrisRecognition.py b/Iris-Recognition-master/Iris-Recognition-master/IrisRecognition.py
new file mode 100644
index 0000000..fe92be4
--- /dev/null
+++ b/Iris-Recognition-master/Iris-Recognition-master/IrisRecognition.py
@@ -0,0 +1,142 @@
+
+# coding: utf-8
+
+import cv2
+import numpy as np
+import glob
+import math
+import scipy
+from scipy.spatial import distance
+from scipy import signal
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn import metrics
+from IrisLocalization import IrisLocalization
+from IrisNormalization import IrisNormalization
+from ImageEnhancement import ImageEnhancement
+from FeatureExtraction import FeatureExtraction
+from IrisMatching import IrisMatching
+from PerformanceEvaluation import PerformanceEvaluation
+import warnings
+warnings.filterwarnings("ignore")
+
+'''TRAINING'''
+
+#reading the training images from the CASIA dataset
+images_train = [cv2.imread(file) for file in sorted(glob.glob('CASIA Iris Image Database (version 1.0)/*/1/*.bmp'))]
+
+#running Localization, Normalization,Enhancement and Feature Extraction on all the training images
+boundary_train,centers_train=IrisLocalization(images_train)
+normalized_train=IrisNormalization(boundary_train,centers_train)
+enhanced_train=ImageEnhancement(normalized_train)
+feature_vector_train=FeatureExtraction(enhanced_train)
+print("Training data processed.")
+
+
+
+'''TESTING'''
+
+#reading the testing images from the CASIA dataset
+images_test = [cv2.imread(file) for file in sorted(glob.glob('CASIA Iris Image Database (version 1.0)/*/2/*.bmp'))]
+
+#running Localization, Normalization,Enhancement and Feature Extraction on all the testing images
+boundary_test,centers_test=IrisLocalization(images_test)
+normalized_test=IrisNormalization(boundary_test,centers_test)
+enhanced_test=ImageEnhancement(normalized_test)
+feature_vector_test=FeatureExtraction(enhanced_test)
+print("Testing data processed.")
+
+
+crr_L1=[]
+crr_L2=[]
+crr_cosine=[]
+y_test=[]
+y_pred=[]
+match_cosine=[]
+match_cosine_ROC=[]
+
+#Performing Matching and CRR scores for 10,40,60,80,90,107 number of dimensions in the reduced feature vector
+components=[10,40,60,80,90,107]
+
+print("Begin Matching test data with the train data")
+for comp in components:
+    
+    #Running matching for all the dimensions specified in "components" 
+    comp_match_L1,comp_match_L2,comp_match_cosine,comp_match_cosine_ROC=IrisMatching(feature_vector_train,feature_vector_test,comp,0)
+    
+    #Calculating CRR for all the dimensions specified in "components" 
+    comp_crr_L1,comp_crr_L2,comp_crr_cosine=PerformanceEvaluation(comp_match_L1,comp_match_L2,comp_match_cosine)
+    
+    #combining the results of all the dimensional feature vector into one array
+    crr_L1.append(comp_crr_L1)
+    crr_L2.append(comp_crr_L2)
+    crr_cosine.append(comp_crr_cosine)
+    match_cosine.append(comp_match_cosine)
+    match_cosine_ROC.append(comp_match_cosine_ROC)
+
+
+#Performing Matching and calculating CRR score for the original feature vector (without dimensionality reduction)
+orig_match_L1,orig_match_L2,orig_match_cosine,orig_match_cosine_ROC=IrisMatching(feature_vector_train,feature_vector_test,0,1)
+orig_crr_L1,orig_crr_L2,orig_crr_cosine=PerformanceEvaluation(orig_match_L1,orig_match_L2,orig_match_cosine)  
+print("Completed Matching")
+
+
+#Table for CRR rates for the original and reduced feature set(components=107)
+print('\n\n\n')
+dict={'Similarity Measure':['L1','L2','Cosine Distance'],'CRR for Original Feature Set':[orig_crr_L1,orig_crr_L2,orig_crr_cosine],'CRR for Reduced Feature Set (107)':[crr_L1[5],crr_L2[5],crr_cosine[5]]}
+table=pd.DataFrame(dict)
+print("Recognition results using Different Similarity Measures : \n")
+print(table.iloc[0],"\n")
+print(table.iloc[1],"\n")
+print(table.iloc[2])
+
+
+# Plotting the incresing CRR for cosine similarity with the incresing dimensionality
+plt.plot(components,crr_cosine)
+plt.axis([10,107,0,100])
+plt.ylabel('Correct Recognition Rate (Cosine)')
+plt.xlabel('Dimensionality of the feature vector')
+plt.title('Recognition Results')
+plt.show()
+
+
+
+#Calculating the false positive and the true positive rates for the data
+#We have taken match_cosine[5] because the 5th instance of the array is for the 107 reduced feature dimension
+fmr_all=[]
+fnmr_all=[]
+
+for q in range(0,3):
+    false_accept=0
+    false_reject=0
+    num_1=len([i for i in match_cosine_ROC[5][q] if i==1])
+    num_0=len([i for i in match_cosine_ROC[5][q] if i==0])
+
+    for p in range(0,len(match_cosine[5])):
+        if match_cosine[5][p]==0 and match_cosine_ROC[5][q][p]==1:
+            false_accept+=1
+        if match_cosine[5][p]==1 and match_cosine_ROC[5][q][p]==0:
+            false_reject+=1
+    fmr=false_accept/num_1
+    fnmr=false_reject/num_0
+    thresh=[0.4,0.5,0.6]
+    fmr_all.append(fmr)
+    fnmr_all.append(fnmr)
+
+
+dict1={'Threshold':thresh,'FMR':fmr_all,'FNMR':fnmr_all}
+roc_table=pd.DataFrame(dict1)
+print("ROC Measures : \n")
+print(roc_table.iloc[0],"\n")
+print(roc_table.iloc[1],"\n")
+print(roc_table.iloc[2])
+
+
+#Plotting the ROC Curve
+plt.plot(fnmr_all,fmr_all)
+plt.title('ROC Curve')
+plt.ylabel('False Non-Match Rate')
+plt.xlabel('False Match Rate')
+plt.show()
+
diff --git a/Iris-Recognition-master/Iris-Recognition-master/PerformanceEvaluation.py b/Iris-Recognition-master/Iris-Recognition-master/PerformanceEvaluation.py
new file mode 100644
index 0000000..5c1f7c7
--- /dev/null
+++ b/Iris-Recognition-master/Iris-Recognition-master/PerformanceEvaluation.py
@@ -0,0 +1,28 @@
+
+# coding: utf-8
+
+import cv2
+import numpy as np
+import glob
+import math
+from scipy.spatial import distance
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn import metrics
+
+def PerformanceEvaluation(match_L1,match_L2,match_cosine):
+    
+    #storing only those elements that are correctly matched
+    correct_L1 = [l for l in match_L1 if l==1]
+    correct_L2 = [l for l in match_L2 if l==1]
+    correct_cosine = [l for l in match_cosine if l==1]
+    
+    
+    #calculating the correct recognition rates for L1,L2 and cosine similarity
+    crr_L1=len(correct_L1)/len(match_L1)
+    crr_L2=len(correct_L2)/len(match_L2)
+    crr_cosine=len(correct_cosine)/len(match_cosine)
+    
+    
+    return crr_L1*100,crr_L2*100,crr_cosine*100 #return CRR percentages
\ No newline at end of file
diff --git a/Iris-Recognition-master/Iris-Recognition-master/README.md b/Iris-Recognition-master/Iris-Recognition-master/README.md
new file mode 100644
index 0000000..94eca5e
--- /dev/null
+++ b/Iris-Recognition-master/Iris-Recognition-master/README.md
@@ -0,0 +1,199 @@
+Iris Recognition
+================
+
+Iris recognition using applied machine learning on CASIA iris images
+dataset
+
+## IrisLocalization.py
+===================
+
+The function IrisLocalization(images) does the following: 
+
+1. It uses a Bilateral filter to remove the noise by blurring the image 
+
+2. We project the image coordinates in the horizontal and vertical directions, and find the minimum(as the minimum would be a dark region of the pupil) to find the approximate center of the pupil. 
+
+3. We next use this approximate center to binarize a 120 x 120 space around the pupil, as defined in the paper, to re-estimate the pupil center. 
+
+4. We perform Canny edge detection on a masked image to get only a few edges around the pupil. If the image was not masked we would get a lot of edges of the eyelashes,etc. 
+
+5. We then implement Hough transformation on the edged image to detect all possible circles in the image. We take the Hough circle that has center closest to the pupil center found as the pupil boundary. 
+
+6. The outer boundary is then drawn by adding 53 to the radius of the inner circle. 
+
+7. The list “boundary” stores all the images with boundaries drawn, while the list “centers” stores the center coordinates.
+
+
+## IrisNormalization.py
+====================
+
+We sequentially load each image from the list boundary returned by the previous function and initialize an empty list to store the normalized images. 
+
+1. In order to project the polar coordinates onto the cartesian plane, we only need to focus on the region between the boundaries. 
+
+2. We define an equally spaced interval over which the for loop iterates to convert polar coordinates to cartesian coordinates, using x=rcos(theta) and y=rsin(theta). 
+
+3. We resize the image to a rectangular 64x512 sized image.
+
+
+ImageEnhancement.py
+===================
+
+In this function, we enhance the image using Histogram Equalization to increase the contrast of the image for better feature extraction.
+
+
+## FeatureExtraction.py
+====================
+
+The functions ‘m’ and ‘gabor’ help in calculating the spatial filter
+defined in the paper
+
+Code: 
+(Images/code1.png)
+
+The function spatial takes f, dx and dy as parameters which are defined
+in the paper. It creates a 8x8 block which we run over the normalized
+image to extract features.
+
+As we have eyelashes and other occlusions present in normalized images,
+we run this 8x8 block over a normalized image of 48\*512, which is our
+region of interest. This helps in further improving the results of
+matching.
+
+Code: 
+(Images/code2.png)
+
+The function above defines this Region of interest and creates two
+channels: filter1 and filter 2, which are then convolved with our RoI to
+get two filtered images.
+
+Code snippet for get\_vec(): 
+(Images/code3.png)
+
+These filtered images are then used to get our feature vector using the
+function ‘get\_vec()’ This function calculates the mean and standard
+deviation values grid by grid, where each grid is a 8x8 block. The
+calculated values are then appended sequentially to the feature vector,
+which is of size 1536 (6x64x4).
+
+
+## IrisMatching.py
+===============
+
+This py file matches our testing and training feature vectors (with and
+without dimensionality reduction).
+
+
+The function dim\_reduction(feature\_vector\_train,feature\_vector\_test,components) does the following: 
+It fits our LDA model to training data.
+Then it transforms both training and testing feature vectors to the number of components specified in the parameters (max 107)
+
+The function IrisMatching(feature\_vector\_train,feature\_vector\_test,components,flag) does the following: 
+
+1. If flag==1 then it performs matching on the
+original feature vector of size 1536. If flag==0 then it performs
+matching on the reduced feature vector of size provided by the
+components parameter. 
+
+2. To perform matching, we calculate the L1, L2
+and cosine distances as defined in the paper for every test image
+against all training samples. Then, the minimum value for all 3
+distances is taken as the matched image and its index is stored. 
+
+3. Next, if the matched index for each image is correct (i.e, the matched
+image is from the same folder as our test image) then it is considered
+as the correct match, and 1 is appended to our “match” list. The same is
+repeated for all three distances to get match\_L1,match\_L2 and
+match\_cosine and they are returned 
+
+4. We also calculate ROC matching here. If the cosine distance is less than the threshold, then it is 1
+(accepted) otherwise it is 0 (rejected). This is stored for all 3 threshold values and returned.
+
+
+## PerformanceEvaluation.py
+========================
+
+This py file calculates the correct recognition rates for our code. The
+function PerformanceEvaluation(match\_L1,match\_L2,match\_cosine) does
+the following:
+
+1. The value of the correct correction rate would be
+given by the count of the eyes that are correctly matched divided by the
+count of the total number of eyes. This is calculated by dividing the
+length of correct\_L1(as it has only those eyes that are correctly
+matched) by length of match\_L1(as it has all the eyes). 
+
+2. Thus, we get the values of crr\_L1,crr\_L2 and crr\_cosine.
+
+## IrisRecognition.py
+==================
+
+This py file is the main file, where we call all the above functions to execute the entire function of iris recognition. 
+
+### 1.
+First, we read and process all training files:
+
+a. Read all files 
+
+b. Run iris localization on all of them and get the images.
+
+c. On the localized images, run normalization and enhancement to get our enhanced images for feature extraction.
+
+d. Then, run feature extraction to get all the feature vectors. 
+
+### 2.
+The same steps a-d are followed for the testing data. 
+
+### 3.
+Once we have our training and testing feature vectors, we run iris matching and performance evaluation on them as:
+
+a. Get matching values and then CRR scores for 10,40,60,80,90 and 107 components in the reduced feature vector 
+  
+b. Use those values to plot the CRR vs Feature Vector dimensions graph 
+  
+c. Get matching values and then CRR scores for our full length 1536 feature vector 
+
+d. Use the 1536 component CRR’s and 107 component CRR’s to plot the table to compare their accuracy 
+  
+### 4.
+ROC requires the rate of false matches and the rate of false non-matches. 
+
+False matches are the number of eyes that are matched but are not authorized whereas
+False non-matches are the number of eyes that are rejected but are
+authorized. To calculate ROC, we use the matching\_cosine\_ROC we got
+from IrisMatching() and compare it with our actual matching\_cosine
+answer to calculate the FMR and FNMR for all three threshold values.
+
+FMR= no. of images incorrectly accepted / total number of accepted
+images
+
+FNMR = no. of images incorrectly rejected / total no of rejected images
+
+
+## Images
+======
+
+This file contains 8 images depicting the step by step output we
+obtained for localization, normalization and enhancement.
+
+Fig1 depicts the grayscale image of the eye
+
+Fig2 depicts the colored image which is what get stored in the target
+array in the Localization function
+
+Fig3 depicts the output of Localization, i.e the original image with
+inner and outer boundaries
+
+Fig4 depicts the Enhanced Normalized 64x512 rectangular image which is
+used for further feature extraction steps
+
+Fig5 shows the recognition results using features of different
+dimensionality
+
+Fig6 table that shows the car for L1,L2,cosine for original and reduced
+feature vectors
+
+Fig7 shows the ROC curve
+
+Fig8 table that shows ROC fmr and fnmr measures for different
+thresholds.