Gabor filter parametrs for fingerprint image enhancement?

Question

i am biggner in image processing and in gabor filter and i want to use this filter to enhance fingerprint image

i read many articles about fingerprint image enhancement and i know that the steps for that is

read image -> noramalize -> get orientation map -> gabor filter -> binarize -> skeleton

now i am in step 4 , my question is how to get the right values for ( lambds and gamma ) for gabor

filter

my image :

my code :

1- read image and get the orientation map using HOG features

imgc = imread(r'C:\Users\iP\Desktop\printe.jpg',as_gray=True)
imgc = resize(imgc, (64*3,128*3))
rows,cols=imgc.shape
offset=24
ori=9    # to get angels (0,45,90,135) only

fd, hog_image = hog(imgc, orientations=ori, pixels_per_cell=(offset, offset),
                cells_per_block=(1, 1), visualize=True, multichannel=None,feature_vector=False
              )

orientation map :

2- reshape the orientation map from (8, 16, 1, 1, 9) to (8, 16, 9),,, 8 ->rows , 16 -> cols , 9 orientation

fd=np.array(fd)
fd=np.reshape(fd,(fd.shape[0],fd.shape[1],ori))

# from (8, 16, 9) to (8, 16, 1)
# Choose the angle that has the most potential ( biggest magntude )
angels=np.zeros((fd.shape[0],fd.shape[1],1))
for r in range(fd.shape[0]):
    for c in range(fd.shape[1]):
       bloc_prop = fd[r,c]
       angelss=bloc_prop.reshape((1,ori))
       angel=np.argmax(angelss)
       angels[r,c]=angel
angels=angels.astype(np.int32)

3- the convolve function

def conv_gabor(img,orient_map,gabor_kernel_shape):
    #
    # loop on all pixels in the image and convolve it with it's angel in the orientation map
    #
    roo,coo=img.shape

    #to get the padding value for immage before convolving it with kernels
    pad=(gabor_kernel_shape-1)


    padded=np.zeros((img.shape[0]+pad,img.shape[1]+pad)) # adding the cols and rows 
    padded[int(pad/2):-int(pad/2),int(pad/2):-int(pad/2)]=img # copy image to inside the padded 
    image

    #result image
    dst=padded.copy()

    # start from the image that inside the padded
    for r in range(int(pad/2),int(pad/2)+roo): 
    
        for c in range(int(pad/2),int(pad/2)+coo):
        
            # get the angel from the orientation map
            ro=(r-int(pad/2))//offset
            co=(c-int(pad/2))//offset
            ang=angels[ro,co]
            real_angel=(((180/ori)*ang))
        
            # bloack around the pixe to convolve it 
            block=padded[r-int(pad/2):r+int(pad/2)+1,c-int(pad/2):c+int(pad/2)+1]
            # get Gabor kernel 
            # here is my question ->> what to get the parametres values for ( lambda and gamma 
            and phi)
            ker= cv2.getGaborKernel( (gabor_kernel_shape,gabor_kernel_shape), 3, 
            np.deg2rad(real_angel),np.pi/4,0.001,0 )
                                
            dst[r,c]=np.sum((ker*block))
    return dst

dst=conv_gabor(imgc,angels,11)

dst :

you see the image is too bad i dont know why this , i think because the lambda and gamma or what ?

but when i filter with one angel only 45 :

ker= cv2.getGaborKernel( (11,11), 2, np.deg2rad(45),np.pi/4,0.5,0 )
filt = cv2.filter2D(imgc,cv2.CV_64F,ker)
plt.imshow(filt,'gray')

reslut :

you see the edges that has 45 on the left is good quality

can anyone help me please , and tell me what should i do in this probelm ?

thanks all :)

EDIT:

i searched for another way and i found that i can use gabor fiter bank with many orientation and get best score in filtred images , so how can i find best score for pixels from filtred images

this is the output when i use gabor fiter bank with 45,60,65,90,135 angels and divide the filtered images to 16*16 and find the highest standard deviation (best score -> i use standard deviation as the score) for each block and get the best filtred image

so as you can see there are good and bad parts in the image ,i think using standard deviation alone is ineffective in some parts of the image , so my new question is what is best score function that gives me good output parts in the image

original image :

Answer 1

In my opinion, weighting the filtered images might be enough for your task. Considering your filter orientations, the filters with angle 45 and 135 respond quite well at different regions of the image. So, you can calculate the weighted sum to get the best filter result.

img = cv2.imread('fingerprint.jpg',0)

w_45 =  0.5
w_135 = 0.5

img_45 = cv2.filter2D(img,cv2.CV_64F,cv2.getGaborKernel( (11,11), 2, np.deg2rad(45),np.pi/4,0.5,0 ))
img_135 = cv2.filter2D(img,cv2.CV_64F,cv2.getGaborKernel( (11,11), 2, np.deg2rad(135),np.pi/4,0.5,0 ))

result = img_45*w_45+img_135*w_135
result = result/np.amax(result)*255

plt.imshow(result,cmap='gray')
plt.show()

Feel free to play with the weights. The result totally depends on what your next step is.