def make_gabor_filters(n_freq, n_orient, base_freq=1,
freq_factor=np.sqrt(2), offset=0):
"""
Generate Gabor filter bank.
n_freq: number of different frequencies
n_orient: number of different orientations
base_freq: base frequency
freq_factor: the multiplicative factor used to derive frequencies, the
frequencies used will be base_freq, base_freq/freq_factor,
base_freq/freq_factor^2, ...
offset: phase offset, almost always set to 0
Return: kernels, a list of kernel matrices. Different frequencies
corresponds to different scales. So the kernel matrices will be of
different sizes. The length of this list will be n_freq x n_orient x 2
"""
kernels = []
n_kernels = n_freq * n_orient * 2
for i_freq in range(n_freq):
freq = 1.0 * base_freq / freq_factor**i_freq
for i_orient in range(n_orient):
theta = np.pi * i_orient / n_orient
kernel = gabor_kernel(freq, theta, offset=offset)
ki = kernel.imag - kernel.imag.sum() / kernel.imag.size
kr = kernel.real - kernel.real.sum() / kernel.real.size
kernels.append(ki / np.abs(ki).max())
kernels.append(kr / np.abs(kr).max())
return kernels
def make_gabor_filters(n_freq,
n_orient,
base_freq=1,
freq_factor=np.sqrt(2),
offset=0):
"""
Generate Gabor filter bank.
n_freq: number of different frequencies
n_orient: number of different orientations
base_freq: base frequency
freq_factor: the multiplicative factor used to derive frequencies, the
frequencies used will be base_freq, base_freq/freq_factor,
base_freq/freq_factor^2, ...
offset: phase offset, almost always set to 0
Return: kernels, a list of kernel matrices. Different frequencies
corresponds to different scales. So the kernel matrices will be of
different sizes. The length of this list will be n_freq x n_orient x 2
"""
kernels = []
n_kernels = n_freq * n_orient * 2
for i_freq in range(n_freq):
freq = 1.0 * base_freq / freq_factor**i_freq
for i_orient in range(n_orient):
theta = np.pi * i_orient / n_orient
kernel = gabor_kernel(freq, theta, offset=offset)
ki = kernel.imag - kernel.imag.sum() / kernel.imag.size
kr = kernel.real - kernel.real.sum() / kernel.real.size
kernels.append(ki / np.abs(ki).max())
kernels.append(kr / np.abs(kr).max())
return kernels
def get_gabor_kernels(num_theta = 4,sigmas=[1,3],freq = [0.05,0.25]):
gaborkernels =[]
for theta in range(num_theta):
theta = theta / float(num_theta) * np.pi
for sigma in sigmas:
for fr in freq:
kernel = np.real(gabor_kernel(fr,theta,sigma_x=sigma,sigma_y=sigma))
gaborkernels.append(kernel)
return gaborkernels
def getGaborKernels(n_theta = 4, sigmas=[1,3], frequencies=[0.05, 0.25]): gaborKernels = [] for theta in range(n_theta): theta = theta / float(n_theta) * np.pi for sigma in sigmas: for frequency in frequencies: kernel = np.real(gabor_kernel(frequency, theta, sigma_x = sigma, sigma_y = sigma)) gaborKernels.append(kernel) return gaborKernels
def update(val):
frequencia = slider_frequencias.val
theta = slider_thetas.val
sigmax = slider_sigmasx.val
sigmay = slider_sigmasy.val
nucleo = np.real(
gabor_kernel(frequencia, theta=theta, sigma_x=sigmax, sigma_y=sigmay))
ax.imshow(nucleo, interpolation='bicubic')
draw()
def gabor():
# prepare filter bank kernels
kernels = []
sigma = 6.0
for f in range(9):
frequency = 1 / (2 * pow(math.sqrt(2), f) )
for theta in range(0, 8):
theta = (np.pi * theta) / 8.0
kernel = np.real(gabor_kernel(frequency, theta=theta, sigma_x=sigma, sigma_y=sigma))
kernels.append(kernel)
fileHandle = open('train_small.csv', 'r')
reader = csv.reader(fileHandle)
#gabor_features = list()
grid_img = Image.new('P', (432, 384))
gab_file = open('gabor_feats.csv', 'w')
row_no = 1
for row in reader:
if (row_no < start_row_no):
row_no = row_no + 1
continue
if (row_no > end_row_no):
break
labelStr, featureStr, tp = row
label = int(labelStr)
features = map(lambda x: float(x), featureStr.split(' '))
trn_2D = np.reshape(np.array(features), (48, 48))
gab_images = compute_feats(trn_2D, kernels)
#with open("gabor_feats.csv", "a") as f:
gab_file.write(labelStr + ',')
pixels_str = ""
for img in gab_images:
img_array = img.ravel()
for pixel in img_array:
pixels_str = pixels_str + (" %.4f" % pixel)
#gab_file.write(s + ' ')
gab_file.write(pixels_str.lstrip() + '\n')
row_no = row_no + 1
#gab_file.write('\n')
gab_file.close()
#for i in range(0, 9):
# for j in range(0, 8):
# grid_img.paste(toimage(gab_images[i*8 + j]), (i * 48, j * 48))
# grid_img.show()
fileHandle.close()
print "Finished extracting gabor features"
def make_gabor_field(self,
X,
zscore=True,
log_amplitude=True,
thetas=range(4),
sigmas=(1, 3),
frequencies=(0.05, 0.25)):
"""Given a spectrogram, prepare 2D patches and Gabor filter bank kernels
inputs:
X - spectrogram data (frequency x time)
zscore - whether to zscore the ensemble of 2D patches [True]
log_amplitude - whether to apply log(1+X) scaling of spectrogram data [True]
thetas - list of 2D Gabor filter orientations in units of pi/4. [range(4)]
sigmas - list of 2D Gabor filter standard deviations in oriented direction [(1,3)]
frequencies - list of 2D Gabor filter frequencies [(0.05,0.25)]
outputs:
self.data - 2D patches of input spectrogram
self.D.components_ - Gabor dictionary of thetas x sigmas x frequencies atoms
"""
self._extract_data_patches(X, zscore, log_amplitude)
self.n_components = len(thetas) * len(sigmas) * len(frequencies)
self.thetas = thetas
self.sigmas = sigmas
self.frequencies = frequencies
a, b = self.patch_size
self.kernels = []
for theta in thetas:
theta = theta / 4. * np.pi
for sigma in sigmas:
for frequency in frequencies:
kernel = np.real(
gabor_kernel(frequency,
theta=theta,
sigma_x=sigma,
sigma_y=sigma))
c, d = kernel.shape
if c <= a:
z = np.zeros(self.patch_size)
z[(a / 2 - c / 2):(a / 2 - c / 2 + c),
(b / 2 - d / 2):(b / 2 - d / 2 + d)] = kernel
else:
z = kernel[(c / 2 - a / 2):(c / 2 - a / 2 + a),
(d / 2 - b / 2):(d / 2 - b / 2 + b)]
self.kernels.append(z.flatten())
class Bunch:
def __init__(self, **kwds):
self.__dict__.update(kwds)
self.D = Bunch(components_=np.vstack(self.kernels))
def gabor_kernel_features(path):
print "Processing image: ", path.split("/")[-1]
galaxy_image = io.imread(path, as_grey=True)
galaxy_image = exposure.rescale_intensity(galaxy_image, out_range=(0,255)) # Improving contrast
galaxy_image = rotateImage(galaxy_image)
kernels = []
for theta in [0, 1, 2, 3]:
theta = theta / 4. * np.pi
for frequency in (0.05, 0.3, 0.5, 0.7):
kernel = gabor_kernel(frequency, theta=theta)
kernels.append(kernel)
galaxy_image = (galaxy_image-galaxy_image.mean())/galaxy_image.std()
feature_vector = compute_gabor_feats(galaxy_image, kernels)
feature_vector = _add_galaxy_id(path, feature_vector)
return feature_vector
def make_filter_bank(frequencies, thetas, real=True):
"""prepare filter bank of Gabor kernels"""
# TODO: set MTF of each filter at (u, v) to 0
kernels = []
kernel_freqs = []
for frequency in frequencies:
sigma_x, sigma_y = _compute_sigmas(frequency)
for theta in thetas:
kernel = gabor_kernel(frequency, theta=theta,
bandwidth=1)
kernels.append(kernel)
kernel_freqs.append(frequency)
if real:
kernels = list(np.real(k) for k in kernels)
return kernels, np.array(kernel_freqs)
def generate_data(ndim, nsamples, nfeatures):
"""Generate data by drawing samples that are a sparse combination of gabor features
"""
# build features
features = list()
for j in range(nfeatures):
theta = np.pi * np.random.rand()
sigma = 2*np.random.rand() + 1
freq = 0.2 * np.random.rand() + 0.05
features.append(resize(np.real(gabor_kernel(freq, theta=theta, sigma_x=sigma, sigma_y=sigma)), (ndim, ndim)).ravel())
features = np.vstack(features)
# draw sparse combinations
X = np.random.laplace(size=(nsamples, nfeatures)) .dot (features)
return X, features
def gabor():
# prepare filter bank kernels
kernels = []
for theta in range(4):
theta = theta / 4. * np.pi
for sigma in (5, 10):
# TODO: check effect of frequency on kernel size
#for frequency in (0.05, 0.25):
for frequency in (0.1, 0.2):
kernel = np.real(gabor_kernel(frequency, theta=theta, sigma_x=sigma, sigma_y=sigma))
kernels.append(kernel)
fileHandle = open('../Datasets/train.csv', 'r')
reader = csv.reader(fileHandle)
#gabor_features = list()
for row in reader:
labelStr, featureStr, tp = row
label = int(labelStr)
features = map(lambda x: float(x), featureStr.split(' '))
trn_2D = np.reshape(np.array(features), (48, 48))
gab_images = compute_feats(trn_2D, kernels)
avg_gab_image = np.zeros_like(gab_images[0])
for ittrImg in range(0, len(gab_images)):
avg_gab_image = avg_gab_image + gab_images[ittrImg]
avg_gab_image = avg_gab_image / len(gab_images)
avg_gab_array = avg_gab_image.ravel()
#gabor_features.append(avg_gab_array)
#print len(gabor_features)
with open("gabor_feats.csv", "a") as f:
writer = csv.writer(f)
writer.writerow(avg_gab_array)
fileHandle.close()
print "Finished extracting gabor features"
def creat_Gabor_Kernels(norientation, sigma, frequency,gamma):
"""This function creats the Gabor kernels with given parameters.
Parameters
----------
norientation: integer
number of orientations
sigmm: float
scale of the kernel
frequency: float
wavelength/frequency of the kernel
"""
kernels = []
for orientation in range(norientation):
theta = orientation / float(norientation) * np.pi
kernel = np.real(gabor_kernel(frequency, theta=theta,
sigma_x=sigma, sigma_y=sigma/float(gamma)))
kernels.append(kernel)
return kernels
def make_gabor_field(self, X, zscore=True, log_amplitude=True, thetas=range(4),
sigmas=(1,3), frequencies=(0.05, 0.25)) :
"""Given a spectrogram, prepare 2D patches and Gabor filter bank kernels
inputs:
X - spectrogram data (frequency x time)
zscore - whether to zscore the ensemble of 2D patches [True]
log_amplitude - whether to apply log(1+X) scaling of spectrogram data [True]
thetas - list of 2D Gabor filter orientations in units of pi/4. [range(4)]
sigmas - list of 2D Gabor filter standard deviations in oriented direction [(1,3)]
frequencies - list of 2D Gabor filter frequencies [(0.05,0.25)]
outputs:
self.data - 2D patches of input spectrogram
self.D.components_ - Gabor dictionary of thetas x sigmas x frequencies atoms
"""
self._extract_data_patches(X, zscore, log_amplitude)
self.n_components = len(thetas)*len(sigmas)*len(frequencies)
self.thetas = thetas
self.sigmas = sigmas
self.frequencies = frequencies
a,b = self.patch_size
self.kernels = []
for theta in thetas:
theta = theta / 4. * np.pi
for sigma in sigmas:
for frequency in frequencies:
kernel = np.real(gabor_kernel(frequency, theta=theta,
sigma_x=sigma, sigma_y=sigma))
c,d = kernel.shape
if c<=a:
z = np.zeros(self.patch_size)
z[(a/2-c/2):(a/2-c/2+c),(b/2-d/2):(b/2-d/2+d)] = kernel
else:
z = kernel[(c/2-a/2):(c/2-a/2+a),(d/2-b/2):(d/2-b/2+b)]
self.kernels.append(z.flatten())
class Bunch:
def __init__(self, **kwds):
self.__dict__.update(kwds)
self.D = Bunch(components_ = np.vstack(self.kernels))
def generateFeature(args):
y_name_train, y_name_test, n_name_train, n_name_test = load_pkl(args['splitPkl'])
print(len(y_name_train))
print(len(y_name_test))
print(len(n_name_train))
print(len(n_name_test))
x_data_train = list()
y_data_train = list()
x_data_test = list()
y_data_test = list()
q = queue.Queue()
q_job = queue.Queue()
kernels = []
for theta in range(4):
theta = theta / 4. * np.pi
for sigma in (1, 3):
for frequency in (0.05, 0.25):
kernel = np.real(gabor_kernel(frequency, theta=theta, sigma_x=sigma, sigma_y=sigma))
kernels.append(kernel)
with Timer("Extracting features"):
for name in y_name_train:
q_job.put(name)
for i, name in enumerate(y_name_train):
print(i, len(y_name_train), name)
t = threading.Thread(target=extractFeature, args = (q, q_job, args['ysmileDir']+'/'+name, args['block_number_x'], args['block_number_y'], kernels))
t.daemon = True
t.start()
y = 1.0
y_data_train.append(y)
q_job.join()
print("qsize: "+str(q.qsize()))
while q.qsize()>0:
x_data_train.append(q.get())
for name in n_name_train:
q_job.put(name)
for i, name in enumerate(n_name_train):
print(i, len(n_name_train), name)
t = threading.Thread(target=extractFeature, args = (q, q_job, args['nsmileDir']+'/'+name, args['block_number_x'], args['block_number_y'], kernels))
t.daemon = True
t.start()
y = -1.0
y_data_train.append(y)
q_job.join()
print("qsize: "+str(q.qsize()))
while q.qsize()>0:
x_data_train.append(q.get())
for name in y_name_test:
q_job.put(name)
for i, name in enumerate(y_name_test):
print(i, len(y_name_test), name)
t = threading.Thread(target=extractFeature, args = (q, q_job, args['ysmileDir']+'/'+name, args['block_number_x'], args['block_number_y'], kernels))
t.daemon = True
t.start()
y = 1.0
y_data_test.append(y)
q_job.join()
print("qsize: "+str(q.qsize()))
while q.qsize()>0:
x_data_test.append(q.get())
for name in n_name_test:
q_job.put(name)
for i, name in enumerate(n_name_test):
print(i, len(n_name_test), name)
t = threading.Thread(target=extractFeature, args = (q, q_job, args['nsmileDir']+'/'+name, args['block_number_x'], args['block_number_y'], kernels))
t.daemon = True
t.start()
y = -1.0
y_data_test.append(y)
q_job.join()
print("qsize: "+str(q.qsize()))
while q.qsize()>0:
x_data_test.append(q.get())
return x_data_train, y_data_train, x_data_test, y_data_test
import tiffLib from scipy import ndimage as nd import scipy from skimage.filter import gabor_kernel import numpy as np import time from numpy.fft import fft, ifft, fft2, ifft2, fftshift dataPath = 'C:/Tomosynthesis/localtest/' fileName = 'test-crop.tif' outputPath = 'C:/Tomosynthesis/localtest/res/' im = ImageIO.imReader(dataPath,fileName, 'tif',2) kernel = np.real(gabor_kernel(0.0185, 0, 20, 20/float(0.9))) print kernel.shape start = time.clock() temp_response = nd.convolve(im.data[0], kernel, mode='nearest') elapsed = (time.clock() - start) print elapsed start = time.clock() data = np.lib.pad(im.data[0], ((0,kernel.shape[0]),(0,kernel.shape[1])),'edge') temp_response_2 = np.fft.irfft2(np.fft.rfft2(data) * np.fft.rfft2(kernel,data.shape)) temp_response_2 = temp_response_2[kernel.shape[0]/2:data.shape[0] - kernel.shape[0]/2,kernel.shape[1]/2:data.shape[1] - kernel.shape[1]/2] elapsed = (time.clock() - start) print elapsed print data.shape
def power(image, kernel):
# Normalize images for better comparison.
image = (image - image.mean()) / image.std()
# 仅仅使用实部
return nd.convolve(image, np.real(kernel), mode="wrap")
# return np.sqrt(nd.convolve(image, np.real(kernel), mode='wrap')**2 +
# nd.convolve(image, np.imag(kernel), mode='wrap')**2)
# Plot a selection of the filter bank kernels and their responses.
results = []
kernel_params = []
for theta in range(4):
theta = theta / 4.0 * np.pi
frequency = 0.1
kernel = gabor_kernel(frequency, theta=theta)
# print(kernel)
params = "theta=%d,\nfrequency=%.2f" % (theta * 180 / np.pi, frequency)
kernel_params.append(params)
# Save kernel and the power image for each image
results.append((kernel, power(test, kernel)))
fig, axes = plt.subplots(nrows=2, ncols=5, figsize=(5, 4))
plt.gray()
# fig.suptitle('Convolutional Layer Using Gabor', fontsize=11)
axes[0][0].axis("off")
# Plot Source image
axes[1][0].imshow(test)
error = np.sum((feats - ref_feats[i, :])**2)
if error < min_error:
min_error = error
min_i = i
return min_i
# prepare filter bank kernels
kernels = []
for theta in range(4):
theta = theta / 4. * np.pi
for sigma in (1, 3):
for frequency in (0.05, 0.25):
kernel = np.real(
gabor_kernel(frequency,
theta=theta,
sigma_x=sigma,
sigma_y=sigma))
kernels.append(kernel)
shrink = (slice(0, None, 3), slice(0, None, 3))
brick = img_as_float(data.load('brick.png'))[shrink]
grass = img_as_float(data.load('grass.png'))[shrink]
wall = img_as_float(data.load('rough-wall.png'))[shrink]
image_names = ('brick', 'grass', 'wall')
images = (brick, grass, wall)
# prepare reference features
ref_feats = np.zeros((3, len(kernels), 2), dtype=np.double)
ref_feats[0, :, :] = compute_feats(brick, kernels)
ref_feats[1, :, :] = compute_feats(grass, kernels)
ref_feats[2, :, :] = compute_feats(wall, kernels)
def _gabor_filter(self, img, f, t):
kernel = gabor_kernel(f, t)
output = cv2.filter2D(img, -1, kernel.real) + 1j * \
cv2.filter2D(img, -1, kernel.imag)
return output
__author__ = 'junwangcas'
import numpy as np
from scipy import ndimage as nd
from skimage import data
from skimage.util import img_as_float
from skimage.filter import gabor_kernel
brick = img_as_float(data.load('brick.png'))
kernel = np.real(gabor_kernel(0.15, theta = 0.5 * np.pi,sigma_x=5, sigma_y=5))
filtered = nd.convolve(brick, kernel, mode='reflect')
mean = filtered.mean()
variance = filtered.var()
from sklearn.decomposition import PCA
# Load faces dataset
file_pkl = open("faces4_data.pkl", "rb")
img,img_name,img_identity,img_pose,img_expression,img_eye,\
identity,pose,expression,eye = pickle.load(file_pkl)
file_pkl.close()
# Extract Gabor features
# Step 1: Prepare Gabor filter bank kernels
kernels = []
for theta in range(4):
theta = theta / 4. * np.pi
for sigma in (1., 2.):
for frequency in (0.5, 1.0):
kernel = np.real(gabor_kernel(frequency,theta=theta,sigma_x=sigma,\
sigma_y=sigma))
kernels.append(kernel)
# Compute Gabor features
feat_gabor = np.zeros((img.shape[0], 16 * 2))
for i in range(img.shape[0]):
img[i] = (img[i] - img[i].min()) / (img[i].max() - img[i].min())
feat_gabor[i, :] = compute_feats(img[i], kernels).reshape(1, 32)
#print i
# PCA on Gabor features
#pca = PCA(n_components=4)
#feat_gabor = pca.fit_transform(feat_gabor)
#print "Variance Ratio: ",sum(pca.explained_variance_ratio_)
#feat_gabor = scale(feat_gabor)
def power(image, kernel):
# Normalize images for better comparison.
image = (image - image.mean()) / image.std()
# 仅仅使用实部
return nd.convolve(image, np.real(kernel), mode='wrap')
#return np.sqrt(nd.convolve(image, np.real(kernel), mode='wrap')**2 +
# nd.convolve(image, np.imag(kernel), mode='wrap')**2)
# Plot a selection of the filter bank kernels and their responses.
results = []
kernel_params = []
for theta in range(4):
theta = theta / 4. * np.pi
frequency = 0.1
kernel = gabor_kernel(frequency, theta=theta)
# print(kernel)
params = 'theta=%d,\nfrequency=%.2f' % (theta * 180 / np.pi, frequency)
kernel_params.append(params)
# Save kernel and the power image for each image
results.append((kernel, power(test, kernel)))
fig, axes = plt.subplots(nrows=2, ncols=5, figsize=(5, 4))
plt.gray()
# fig.suptitle('Convolutional Layer Using Gabor', fontsize=11)
axes[0][0].axis('off')
# Plot Source image
axes[1][0].imshow(test)
import cv2
import numpy as np
import timeit
import image_functions
from skimage.filter import gabor_kernel
from scipy import ndimage as nd
kernels = []
for theta in range(4):
theta = theta / 4. * np.pi
for sigma in (1, 3):
for frequency in (0.05, 0.25):
kernel = np.real(gabor_kernel(frequency, theta=theta,
sigma_x=sigma, sigma_y=sigma))
kernels.append(kernel)
def gabor_features(filename):
I = cv2.imread(filename).astype(np.float32)[:,:,1]
feats = np.zeros((len(kernels), 2), dtype=np.double)
for k, kernel in enumerate(kernels):
filtered = nd.convolve(I, kernel, mode='wrap')
feats[k, 0] = filtered.mean()
feats[k, 1] = filtered.var()
return np.concatenate(feats)
def color_features(filename):
I = cv2.imread(filename).astype(np.float32)
h, w, dim = I.shape
G = np.mean(I, axis = 2)
G2 = np.dstack((G,G,G))
C = cv2.resize(np.subtract(I, G2), (8, 8))
from pylab import *
from matplotlib.widgets import Slider, Button, RadioButtons
ax = subplot(111, axisbg=(0.44, 0.44, 0.44))
subplots_adjust(bottom=0.35)
gray()
axis([0, 30, 0, 30])
theta_init = np.pi / 2
freq_init = 0.25
sigmax_init = 3
sigmay_init = 3
nucleo = np.real(
gabor_kernel(freq_init,
theta=theta_init,
sigma_x=sigmax_init,
sigma_y=sigmay_init))
ax.imshow(nucleo, interpolation='bicubic')
axcolor = 'lightgoldenrodyellow'
frequencias = axes([0.25, 0.1, 0.65, 0.03], axisbg=axcolor)
thetas = axes([0.25, 0.15, 0.65, 0.03], axisbg=axcolor)
sigmasx = axes([0.25, 0.20, 0.65, 0.03], axisbg=axcolor)
sigmasy = axes([0.25, 0.25, 0.65, 0.03], axisbg=axcolor)
slider_frequencias = Slider(frequencias, 'Freq', 0.05, 0.50, valinit=freq_init)
slider_thetas = Slider(thetas, 'Theta', 0, np.pi, valinit=theta_init)
slider_sigmasx = Slider(sigmasx, 'Sigma X', 1, 6, valinit=sigmax_init)
slider_sigmasy = Slider(sigmasy, 'Sigma Y', 1, 6, valinit=sigmay_init)
