Add Gabor filter,a linear filter used for texture analysis, which means that it basically analyzes whether there are any specific frequency content in the image in specific directions in a localized region around the point or region of analysis

Author: rishavk99

Image_Processing/src/Filters/src/gabor filter/__pycache__/frequest.cpython-37.pyc

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Apr 22 02:51:53 2016
+
+@author: utkarsh
+"""
+
+
+
+# FREQEST - Estimate fingerprint ridge frequency within image block
+#
+# Function to estimate the fingerprint ridge frequency within a small block
+# of a fingerprint image.  This function is used by RIDGEFREQ
+#
+# Usage:
+#  freqim =  freqest(im, orientim, windsze, minWaveLength, maxWaveLength)
+#
+# Arguments:
+#         im       - Image block to be processed.
+#         orientim - Ridge orientation image of image block.
+#         windsze  - Window length used to identify peaks. This should be
+#                    an odd integer, say 3 or 5.
+#         minWaveLength,  maxWaveLength - Minimum and maximum ridge
+#                     wavelengths, in pixels, considered acceptable.
+# 
+# Returns:
+#         freqim    - An image block the same size as im with all values
+#                     set to the estimated ridge spatial frequency.  If a
+#                     ridge frequency cannot be found, or cannot be found
+#                     within the limits set by min and max Wavlength
+#                     freqim is set to zeros.
+#
+# Suggested parameters for a 500dpi fingerprint image
+#   freqim = freqest(im,orientim, 5, 5, 15);
+#
+# See also:  RIDGEFREQ, RIDGEORIENT, RIDGESEGMENT
+
+### REFERENCES
+
+# Peter Kovesi 
+# School of Computer Science & Software Engineering
+# The University of Western Australia
+# pk at csse uwa edu au
+# http://www.csse.uwa.edu.au/~pk
+
+
+import numpy as np
+import math
+import scipy.ndimage
+#import cv2
+def frequest(im,orientim,windsze,minWaveLength,maxWaveLength):
+    rows,cols = np.shape(im);
+    
+    # Find mean orientation within the block. This is done by averaging the
+    # sines and cosines of the doubled angles before reconstructing the
+    # angle again.  This avoids wraparound problems at the origin.
+        
+    
+    cosorient = np.mean(np.cos(2*orientim));
+    sinorient = np.mean(np.sin(2*orientim));    
+    orient = math.atan2(sinorient,cosorient)/2;
+    
+    # Rotate the image block so that the ridges are vertical    
+    
+    #ROT_mat = cv2.getRotationMatrix2D((cols/2,rows/2),orient/np.pi*180 + 90,1)    
+    #rotim = cv2.warpAffine(im,ROT_mat,(cols,rows))
+    rotim = scipy.ndimage.rotate(im,orient/np.pi*180 + 90,axes=(1,0),reshape = False,order = 3,mode = 'nearest');
+
+    # Now crop the image so that the rotated image does not contain any
+    # invalid regions.  This prevents the projection down the columns
+    # from being mucked up.
+    
+    cropsze = int(np.fix(rows/np.sqrt(2)));
+    offset = int(np.fix((rows-cropsze)/2));
+    rotim = rotim[offset:offset+cropsze][:,offset:offset+cropsze];
+    
+    # Sum down the columns to get a projection of the grey values down
+    # the ridges.
+    
+    proj = np.sum(rotim,axis = 0);
+    dilation = scipy.ndimage.grey_dilation(proj, windsze,structure=np.ones(windsze));
+
+    temp = np.abs(dilation - proj);
+    
+    peak_thresh = 2;    
+    
+    maxpts = (temp<peak_thresh) & (proj > np.mean(proj));
+    maxind = np.where(maxpts);
+    
+    rows_maxind,cols_maxind = np.shape(maxind);
+    
+    # Determine the spatial frequency of the ridges by divinding the
+    # distance between the 1st and last peaks by the (No of peaks-1). If no
+    # peaks are detected, or the wavelength is outside the allowed bounds,
+    # the frequency image is set to 0    
+    
+    if(cols_maxind<2):
+        freqim = np.zeros(im.shape);
+    else:
+        NoOfPeaks = cols_maxind;
+        waveLength = (maxind[0][cols_maxind-1] - maxind[0][0])/(NoOfPeaks - 1);
+        if waveLength>=minWaveLength and waveLength<=maxWaveLength:
+            freqim = 1/np.double(waveLength) * np.ones(im.shape);
+        else:
+            freqim = np.zeros(im.shape);
+        
+    return(freqim);
+    

Image_Processing/src/Filters/src/gabor filter/__pycache__/image_enhance.cpython-37.pyc

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Apr 18 11:42:58 2016
+
+@author: utkarsh
+"""
+
+import numpy as np
+#import cv2
+#import numpy as np;
+import matplotlib.pylab as plt;
+import scipy.ndimage
+import sys
+import cv2
+
+from image_enhance import image_enhance
+
+
+if(len(sys.argv)<2):
+    print('loading sample image');
+    img_name = '01.jpg'
+    img = scipy.ndimage.imread('images/' + img_name);
+    
+elif(len(sys.argv) >= 2):
+    img_name = sys.argv[1];
+    img = scipy.ndimage.imread(sys.argv[1]);
+    
+if(len(img.shape)>2):
+    # img = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+    img = np.dot(img[...,:3], [0.299, 0.587, 0.114]);
+    
+    
+print(img.shape)
+
+rows,cols = np.shape(img);
+aspect_ratio = np.double(rows)/np.double(cols);
+
+new_rows = 350;             # randomly selected number
+new_cols = new_rows/aspect_ratio;
+
+#img = cv2.resize(img,(new_rows,new_cols));
+img = scipy.misc.imresize(img,(np.int(new_rows),np.int(new_cols)));
+
+enhanced_img = image_enhance(img);
+enhanced_img = 255*np.uint8(enhanced_img)
+kernel = np.ones((5,5),np.uint8)
+# closing = cv2.morphologyEx(enhanced_img, cv2.MORPH_OPEN, kernel)
+erosion = cv2.erode(enhanced_img,kernel,iterations = 1)
+
+cv2.imshow('output',enhanced_img)
+cv2.waitKey(0)
+
+   
+
+if(1):
+    print('saving the image')
+    scipy.misc.imsave('../enhanced/' + img_name, enhanced_img)
+else:
+    plt.imshow(enhanced_img,cmap = 'Greys_r');

Image_Processing/src/Filters/src/gabor filter/__pycache__/ridge_filter.cpython-37.pyc

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Apr 18 22:50:30 2016
+
+@author: utkarsh
+"""
+from ridge_segment import ridge_segment
+from ridge_orient import ridge_orient
+from ridge_freq import ridge_freq
+from ridge_filter import ridge_filter
+import cv2
+import numpy as np
+import scipy.ndimage
+
+def image_enhance(img):
+    blksze = 40;
+    thresh=0.1
+    normim,mask = ridge_segment(img,blksze,thresh);             # normalise the image and find a ROI
+    temp=normim -normim.min()
+    temp =temp/temp.max()
+    cv2.imshow("normim",normim)
+    cv2.waitKey(0)
+
+    gradientsigma = 1;
+    blocksigma = 9;
+    orientsmoothsigma = 7;
+    orientim = ridge_orient(normim, gradientsigma, blocksigma, orientsmoothsigma);              # find orientation of every pixel
+    cv2.imshow("orientim",orientim)
+    cv2.waitKey(0)
+
+    blksze = 50;
+    windsze = 5;
+    minWaveLength = 5;
+    maxWaveLength = 15;
+    freq,medfreq = ridge_freq(normim, mask, orientim, blksze, windsze, minWaveLength,maxWaveLength);    #find the overall frequency of ridges
+    
+    
+    freq = medfreq*mask;
+    kx = 0.65;ky = 0.65;
+    newim = ridge_filter(normim, orientim, freq, kx, ky);       # create gabor filter and do the actual filtering
+    # temp=newim-newim.min();
+    # temp = temp/temp.max()
+    # cv2.imshow('output',newim)
+    # cv2.waitKey(0)
+   
+   
+    #gray = cv2.cvtColor(newim, cv2.COLOR_BGR2GRAY)    
+    #thresholding
+    th, bin_im = cv2.threshold(np.uint8(newim),0,255,cv2.THRESH_BINARY);
+    # cv2.imshow('out',bin_im)
+    # cv2.waitKey(0)
+    # th3 = cv2.adaptiveThreshold((bin_im).astype('uint8'),255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,2)
+            
+    # cv2.imshow('out',th3)
+    # kernel = np.ones((5,5),np.uint8)
+    # closing = cv2.morphologyEx(bin_im, cv2.MORPH_OPEN, kernel)
+    # cv2.imshow('outclosed',closing)
+    # cv2.waitKey(0)
+
+    cv2.waitKey(0)
+    return(newim<th )