def DoG(image_name, Test=False, perceptron=False):
train_path = "/home/rajiv/Documents/lectures/BIC/project_conv_sdnn/datasets/TrainingSet/Face/"
test_path = "/home/rajiv/Documents/lectures/BIC/project_conv_sdnn/datasets/TestingSet/faces_labeled/"
perceptron_path = "/home/rajiv/Documents/lectures/BIC/project_conv_sdnn/datasets/TrainingSet/faces_labeled/"
if Test:
image = Image.open(test_path + image_name)
image = np.array(image.resize((400, 400), Image.BILINEAR))
filtered_image = difference_of_gaussians(image, 1.5)
filtered_image = np.expand_dims(filtered_image, axis=0)
filtered_image = np.expand_dims(filtered_image, axis=0)
return filtered_image
elif perceptron:
image = Image.open(perceptron_path + image_name)
image = np.array(image.resize((400, 400), Image.BILINEAR))
filtered_image = difference_of_gaussians(image, 1.5)
filtered_image = np.expand_dims(filtered_image, axis=0)
filtered_image = np.expand_dims(filtered_image, axis=0)
return filtered_image
else:
image = Image.open(train_path + image_name)
image = np.array(image.resize((400, 400), Image.BILINEAR))
filtered_image = difference_of_gaussians(image, 1.5)
filtered_image = np.expand_dims(filtered_image, axis=0)
filtered_image = np.expand_dims(filtered_image, axis=0)
return filtered_image
def get_filted(img, k, sigma):
filted = difference_of_gaussians(img, sigma, k * sigma)
filter_img = filted * window('hann', img.shape)
result = fftshift(np.abs(fftn(filter_img)))
result = cv2.normalize(result, result, 0, 1, cv2.NORM_MINMAX)
result = np.uint8(result * 255.)
return result
def mask_area(img, scale):
class Map_coord():
"""CV2 class for storing left button clicks
Notes
----------
Loads button clicks through cv2 and saves them in a list instantiated with the class
"""
def __init__(self):
self.points = []
def select_point(self, event, x, y, flags, param):
if event == cv2.EVENT_LBUTTONDOWN:
self.points.append([x, y])
cv2.drawMarker(frame, (x, y), (0, 0, 0),
markerType=cv2.MARKER_CROSS,
markerSize=15,
thickness=2)
cv2.imshow("image", frame)
#Instantiate class for getting button clicks
coordinateStore = Map_coord()
frame = normalize(difference_of_gaussians(img, 1, 5))
frame = cv2.resize(frame, (0, 0), fx=scale, fy=scale)
cv2.imshow("image", frame)
cv2.namedWindow("image")
cv2.setMouseCallback("image", coordinateStore.select_point)
while (1):
cv2.imshow('image', frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
cv2.destroyAllWindows()
coords = []
for elements in coordinateStore.points:
coords.append(list(elements)[::])
for obj in coords:
if obj in sorted(coords, key=lambda l: l[1])[:2]:
obj[1] = 0
if obj in sorted(coords, key=lambda l: l[1])[-2:]:
obj[1] = frame.shape[0]
coords = [np.array(coords)]
if len(coords[0]) > 4:
stencil = np.zeros(frame.shape).astype(frame.dtype)
color = [255, 255, 255]
cv2.fillPoly(stencil, coords, color)
return imutils.resize(stencil, width=img.shape[1], height=img.shape[0])
else:
return None
def test_auto_sigma2(s):
image = np.random.rand(10, 10)
im1 = gaussian(image, s, preserve_range=True)
s2 = 1.6 * np.array(s)
im2 = gaussian(image, s2, preserve_range=True)
dog = im1 - im2
dog2 = difference_of_gaussians(image, s, s2)
assert np.allclose(dog, dog2)
def test_dog_invalid_sigma_dims():
image = np.ones((5, 5, 3))
with pytest.raises(ValueError):
difference_of_gaussians(image, (1, 2))
with pytest.raises(ValueError):
difference_of_gaussians(image, 1, (3, 4))
with pytest.raises(ValueError):
with expected_warnings(["`multichannel` is a deprecated argument"]):
difference_of_gaussians(image, (1, 2, 3), multichannel=True)
with pytest.raises(ValueError):
difference_of_gaussians(image, (1, 2, 3), channel_axis=-1)
def test_difference_of_gaussians(s, s2, channel_axis):
image = np.random.rand(10, 10)
if channel_axis is not None:
n_channels = 5
image = np.stack((image, ) * n_channels, channel_axis)
im1 = gaussian(image, s, preserve_range=True, channel_axis=channel_axis)
im2 = gaussian(image, s2, preserve_range=True, channel_axis=channel_axis)
dog = im1 - im2
dog2 = difference_of_gaussians(image, s, s2, channel_axis=channel_axis)
assert np.allclose(dog, dog2)
def best_z(self, crop):
"""
Returns crop Z plane with the max average intensity in a central 3x3 square after applying a bandpass filter
"""
crop_pad = self.crop_pad
return np.argmax(
np.mean(difference_of_gaussians(crop, 1,
7)[:, crop_pad - 1:crop_pad + 2,
crop_pad - 1:crop_pad + 2],
axis=(1, 2)))
def _find_angle(img_original, img_deformed):
# First, band-pass filter both images
image = img_original
rts_image = img_deformed
image = difference_of_gaussians(image, 5, 15)
rts_image = difference_of_gaussians(rts_image, 5, 15)
# window images
wimage = image * window('hann', image.shape)
rts_wimage = rts_image * window('hann', rts_image.shape)
# work with shifted FFT magnitudes
image_fs = np.abs(fftshift(fft2(wimage)))
rts_fs = np.abs(fftshift(fft2(rts_wimage)))
# Create log-polar transformed FFT mag images and register
shape_or = image_fs.shape
shape_def = rts_fs.shape
radius_or = shape_or[0] // 8
radius_def = shape_def[0] // 8 # only take lower frequencies
warped_image_fs = warp_polar(image_fs,
radius=radius_or,
output_shape=shape_or,
scaling='log',
order=0)
warped_rts_fs = warp_polar(rts_fs,
radius=radius_def,
output_shape=shape_or,
scaling='log',
order=0)
warped_image_fs = warped_image_fs[:shape_or[
0], :] # only use half of FFT
warped_rts_fs = warped_rts_fs[:shape_or[0], :]
shifts, error, phasediff = phase_cross_correlation(warped_image_fs,
warped_rts_fs,
upsample_factor=10)
# Use translation parameters to calculate rotation and scaling parameters
shiftr, shiftc = shifts[:2]
recovered_angle = (360 / shape_or[0]) * shiftr
return recovered_angle
def wavelet(I, level, wavelet="db3", threshold=64.0, hard=True):
mode = "symmetric"
result = np.zeros_like(I)
print(I.shape)
for i in range(I.shape[0]):
s = np.zeros_like(result[i, :])
s[0:I.shape[1], 0:I.shape[2]] = I[i, :]
arr = np.float32(s)
print(f"arr.shape {arr.shape}")
coeffs = wavedec2(arr, wavelet=wavelet, level=7)
coeffs_H = list(coeffs)
idx = int(level)
if hard:
for idx in range(idx, 7):
for idx2 in [0, 1, 2]:
#print(np.mean(coeffs_H[idx][idx2]), np.max(coeffs_H[idx][idx2]), np.min(coeffs_H[idx][idx2]))
coeffs_H[idx][idx2][coeffs_H[idx][idx2] < threshold] = 0
#coeffs_H[-idx] == tuple([np.zeros_like(v) for v in coeffs_H[-idx]])
else:
for idx in range(idx, 0, -1):
for idx2 in [0, 1, 2]:
coeffs_H[idx] = list(coeffs_H[idx])
#coeffs_H[idx][idx2] = np.sign(coeffs_H[idx][idx2]) * np.abs(coeffs_H[idx][idx2] + threshold)
coeffs_H[idx][idx2][coeffs_H[idx][idx2] <
threshold] = difference_of_gaussians(
coeffs_H[idx][idx2]
[coeffs_H[idx][idx2] < threshold],
1)
# if hard:
# coeffs_H[idx][1][coeffs_H[idx][1] < threshold] = 0
# else:
# coeffs_H[idx][1] = np.sign(coeffs_H[idx][1]) * np.abs(coeffs_H[idx][1] - threshold)
arr_rec = waverec2(coeffs_H, wavelet=wavelet)
print(f"arr_rec {arr_rec.shape}")
result[i, 0:I.shape[1], 0:I.shape[2]] = arr_rec[0:I.shape[1],
0:I.shape[2]].copy()
return result
def compute_dgfw(
image: np.ndarray,
gaussdiff: Sequence[float] = (5, 20),
windowweight: float = 1,
windowtype: str = "hann",
) -> np.ndarray:
"""Image Difference of Gaussian Filter + Window.
Parameters
----------
image : numpy.ndarray
The input image to filter
gaussdiff : (float, float), optional
The low and high standard deviations for the gaussian difference band pass filter
windowweight : float, optional
weighting factor scaling beween windowed image and image
windowtype : str, optional
see `skimage.filters.window` for possible choices
Returns
-------
numpy.ndarray
modified image with bandpass filter and window applied
Notes
-----
Applying this bandpass and window filter prevents artifacts from image boundaries and
noise from contributing significantly to the fourier transform. The gaussian
difference filter can be tuned such that the features relevant for the identification
of the rotation angle are at the center of the band pass filter.
"""
image_dgfw = (
difference_of_gaussians(image, *gaussdiff)
if gaussdiff[0] < gaussdiff[1]
else image * 1.0
)
image_dgfw *= windowweight * window(windowtype, image.shape) + (
1 - windowweight
)
return cast(np.ndarray, image_dgfw)
def analyse(self):
all_wells=[]
for well in range(self.img_set.sizes['v']):
self.img_set.default_coords['v'] = well
res=[]
if self.mask[well] is not None:
for img in self.img_set:
passed=[]
im=difference_of_gaussians(img, 1, 5)
blur=gaussian(im, sigma=2)
black=black_tophat(blur, selem=disk(4))
thresh=threshold_otsu((black))
black=black*self.mask[well].astype(bool).astype(int)
objects=regionprops(ndi.label(black>thresh)[0])
for obj in objects:
if obj.area>self.min_area and obj.area<self.max_area:
passed.append(obj.area)
res.append(len(passed))
else:
res.append([])
all_wells.append(res)
with open("out.csv", "w", newline="") as f:
writer = csv.writer(f)
writer.writerows(res)
def fourier_affine(self, img0, img1, masks=None, verbose=False):
"""Estimate translations by masked normalized
cross-correlation after fourier transformation
img0, img1 (numpy.ndarray [height, width]): input images
masks (tuple): masks for keypoint detection
verbose (bool): return additional diagnostic values
Returns:
np.ndarray or NoneType: affine transform to fit
img1 onto img0, None if RMSE is > 0.4
dict: diagnostics (if verbose)
"""
# preprocess the images
# First, band-pass filter both images
low_sigma = 1
high_sigma = None
img0_dog = difference_of_gaussians(img0,
low_sigma=low_sigma,
high_sigma=high_sigma)
img1_dog = difference_of_gaussians(img1,
low_sigma=low_sigma,
high_sigma=high_sigma)
# find translations masked on non-masked
if masks is not None:
assert len((img0, img1)) == len(masks), 'Incorrect number of masks'
mask0, mask1 = masks
shifts = phase_cross_correlation(img1_dog,
img0_dog,
reference_mask=mask1,
moving_mask=mask0)
y_shift, x_shift = shifts[:2]
if verbose:
diag = {
'low_sigma': low_sigma,
'high_sigma': high_sigma,
'y_shift_scaled': y_shift,
'x_shift_scaled': x_shift
}
else:
shifts, error, phasediff = phase_cross_correlation(
img1_dog, img0_dog, upsample_factor=10)
y_shift, x_shift = shifts[:2]
if verbose:
diag = {
'low_sigma': low_sigma,
'high_sigma': high_sigma,
'y_shift_scaled': y_shift,
'x_shift_scaled': x_shift,
'RMSE_shift': error,
'phasediff_shift': phasediff
}
# if error > 0.4 result is not acceptable
if error > 0.4:
return (None, diag) if verbose else None
translation = np.array([[1, 0, x_shift], [0, 1, y_shift], [0, 0, 1]],
dtype=np.float32)
return (translation, diag) if verbose else translation
print(imgname)
# Load raw image file and read pixel size from metadata
#filepath = os.path.join(dirpath, imgname)
with tifffile.TiffFile(filepath) as tif:
imgraw = tif.pages[0].asarray() # image as numpy array
pxs_nm = 1e9 / tif.pages[0].tags['XResolution'].value[
0] # pixel size in nm
# Get binary mask and multiple the pre-processed image with this (should I do this before pre-processing? does it make a difference?).
binarymap = binary_cell_map(imgraw, pxs_nm=pxs_nm)
img = imgraw * binarymap
# Preprocess image with a difference of gaussians filter and a gaussian blurring
# take the difference of gaussians to minimize faint out of focus noise
img = skfilt.difference_of_gaussians(img,
low_sigma=0,
high_sigma=difgaus_sigmahi_nm /
pxs_nm)
img[img < 0] = 0 # remove any negative values in the image
# gaussian smoothing of the image
img = ndi.gaussian_filter(img, sm_size_nm / pxs_nm)
# If necessary: standardize image by dividing by mean+std, to get all images to ~the same range of values (assuming similar intensity distr)
# Else: multiply by a fix factor to get values to roughly the same range
if standbool:
peakthresh = peakthresh_stand_true
imgmean = np.ma.masked_array(img, ~binarymap).mean()
imgstd = np.ma.masked_array(img, ~binarymap).std()
img = np.array(img / (imgmean + imgstd))
else:
peakthresh = peakthresh_stand_false
img = img * multfact
def FFT_SOBEL(channel):
filtered_image = filters.difference_of_gaussians(channel, 1, 12)
wimage = filtered_image * filters.window('hann', channel.shape)
im_f_mag = fftshift(np.abs(fftn(wimage)))
image = filters.sobel(np.log(im_f_mag))
return image
def SOBEL_FFT(channel):
image = filters.sobel(channel)
image = filters.difference_of_gaussians(image, 0, 12)
image = image * filters.window('hann', (32, 32))
image = fftshift(np.abs(fftn(image)))
return np.log(image)
def filter_data(data, sigmas=1, sigmab=10):
output = difference_of_gaussians(data, sigmas, sigmab)
return output
kwargs = {'sigmas': [0.7], 'mode': 'reflect'}
Gimage = filters.gaussian(Nimage, sigma=0.7)
cv.imwrite(os.path.join(PATH + '2-Gaussian filter_' + name), Gimage)
GN = cv.normalize(Gimage, None, 0, 255, cv.NORM_MINMAX)
GNN = GN.astype(np.uint8) ### APPLYING Gaussian smooth filter
Eimage = filters.sobel(GN)
cv.imwrite(os.path.join(PATH + '3- Sobel Edge detection_' + name), Eimage)
Eimage += Nimage
EN = cv.normalize(Eimage, None, 0, 255, cv.NORM_MINMAX)
ENN = EN.astype(np.uint8) ### APPLYING Sobel edge detection filter
DoG = filters.difference_of_gaussians(Gimage, 0.7)
# cv.imwrite(os.path.join(PATH+'DoG_'+name), DoG)
DoG += Nimage
DoGN = cv.normalize(DoG, None, 0, 255, cv.NORM_MINMAX)
DoGNN = DoGN.astype(np.uint8) ### APPLYING Difference of Gaussian filter
LoG = ndimage.gaussian_laplace(Gimage, sigma=0.7)
# cv.imwrite(os.path.join(PATH+'LoG_'+name), LoG)
LoG += Nimage
LoGN = cv.normalize(LoG, None, 0, 255, cv.NORM_MINMAX)
LoGNN = LoGN.astype(np.uint8) ### APPLYING Laplacian of Gaussian filter
GGM = ndimage.gaussian_gradient_magnitude(Gimage, sigma=0.7)
# cv.imwrite(os.path.join(PATH+'GGM_'+name), GGM)
GGM += Nimage
GGMN = cv.normalize(GGM, None, 0, 255, cv.NORM_MINMAX)
def create_features(image, parameters=None):
"""
Creates set of features for data classification
Parameters
----------
image : greyscale image for segmentation
trainable segmentation parameters
Returns
-------
set of chosen features of the inputted image.
"""
if parameters == None:
parameters = trainable_parameters()
shape = [image.shape[0], image.shape[1], 1]
image_stack = np.zeros(shape, dtype=np.float16)
one_im = rescale_intensity(image, out_range = (-1,1))
temp = util.img_as_ubyte(rescale_intensity(image, out_range=(0,1)))
if parameters.gaussian[0]:
new_layer = np.reshape(filters.gaussian(image,parameters.gaussian[1]),shape)
image_stack = np.concatenate((image_stack, new_layer), axis=2)
if parameters.diff_gaussian[0]:
par = parameters.diff_gaussian
if par[1][0]:
blur = filters.gaussian(image,par[1][1])
new_layer = np.reshape(filters.difference_of_gaussians(blur, low_sigma=par[2],high_sigma=par[3]), shape)
else:
new_layer = np.reshape(filters.difference_of_gaussians(image, low_sigma=par[2],high_sigma=par[3]), shape)
image_stack = np.concatenate((image_stack, new_layer), axis=2)
if parameters.median[0]:
par = parameters.median
if par[1][0]:
blur = filters.gaussian(one_im,par[1][1])
new_layer = np.reshape(filters.median(blur, morphology.disk(par[2])),shape)
else:
new_layer = np.reshape(filters.median(one_im, morphology.disk(par[2])),shape)
image_stack = np.concatenate((image_stack, new_layer), axis=2)
if parameters.minimum[0]:
par = parameters.minimum
if par[1][0]:
blur = filters.gaussian(temp,par[1][1])
new_layer = np.reshape(filters.rank.minimum(blur, morphology.disk(par[2])),shape)
else:
new_layer = np.reshape(filters.rank.minimum(temp, morphology.disk(par[2])),shape)
image_stack = np.concatenate((image_stack, new_layer), axis=2)
if parameters.maximum[0]:
par = parameters.maximum
if par[1][0]:
blur = filters.gaussian(temp,par[1][1])
new_layer = np.reshape(filters.rank.maximum(blur, morphology.disk(par[2])),shape)
else:
new_layer = np.reshape(filters.rank.maximum(temp, morphology.disk(par[2])),shape)
image_stack = np.concatenate((image_stack, new_layer), axis=2)
if parameters.sobel[0]:
par = parameters.sobel
if par[1][0]:
blur = filters.gaussian(image,par[1][1])
new_layer = np.reshape(filters.sobel(blur),shape)
else:
new_layer = np.reshape(filters.sobel(image),shape)
image_stack = np.concatenate((image_stack, new_layer), axis=2)
if parameters.hessian[0]:
par = parameters.hessian
if par[1][0]:
blur = filters.gaussian(image,par[1][1])
new_layer = np.reshape(filters.hessian(blur),shape)
else:
new_layer = np.reshape(filters.hessian(image),shape)
image_stack = np.concatenate((image_stack, new_layer), axis=2)
if parameters.laplacian[0]:
par = parameters.laplacian
if par[1][0]:
blur = filters.gaussian(image,par[1][1])
new_layer = np.reshape(laplacian(blur),shape)
else:
new_layer = np.reshape(filters.laplacian(image),shape)
image_stack = np.concatenate((image_stack, new_layer), axis=2)
if True in parameters.membrane[1:]:
par = parameters.membrane
if par[0][0]:
temp_im = filters.gaussian(image,par[0][1])
else:
temp_im = image
indexes = np.asarray(par[1:], dtype=np.bool_)
mem_layers = membrane_projection(image)[:,:,indexes]
if par[1:] == [1,1,1,1,1,1]:
mem_layers = np.squeeze(mem_layers)
image_stack = np.append(image_stack, mem_layers, axis=2)
return image_stack[:,:,1:]
filtering.
"""
######################################################################
# Denoise image and reduce shadows
# ================================
import matplotlib.pyplot as plt
import numpy as np
from skimage.data import gravel
from skimage.filters import difference_of_gaussians, window
from scipy.fftpack import fftn, fftshift
image = gravel()
wimage = image * window('hann', image.shape) # window image to improve FFT
filtered_image = difference_of_gaussians(image, 1, 12)
filtered_wimage = filtered_image * window('hann', image.shape)
im_f_mag = fftshift(np.abs(fftn(wimage)))
fim_f_mag = fftshift(np.abs(fftn(filtered_wimage)))
fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(8, 8))
ax[0, 0].imshow(image, cmap='gray')
ax[0, 0].set_title('Original Image')
ax[0, 1].imshow(np.log(im_f_mag), cmap='magma')
ax[0, 1].set_title('Original FFT Magnitude (log)')
ax[1, 0].imshow(filtered_image, cmap='gray')
ax[1, 0].set_title('Filtered Image')
ax[1, 1].imshow(np.log(fim_f_mag), cmap='magma')
ax[1, 1].set_title('Filtered FFT Magnitude (log)')
plt.show()
print()
print(f'Expected value for scaling difference: {scale}')
print(f'Recovered value for scaling difference: {shift_scale}')
######################################################################
# Register rotation and scaling on a translated image - Part 2
# =================================================================
#
# We next show how rotation and scaling differences, but not translation
# differences, are apparent in the frequency magnitude spectra of the images.
# These differences can be recovered by treating the magnitude spectra as
# images themselves, and applying the same log-polar + phase correlation
# approach taken above.
# First, band-pass filter both images
image = difference_of_gaussians(image, 5, 20)
rts_image = difference_of_gaussians(rts_image, 5, 20)
# window images
wimage = image * window('hann', image.shape)
rts_wimage = rts_image * window('hann', image.shape)
# work with shifted FFT magnitudes
image_fs = np.abs(fftshift(fft2(wimage)))
rts_fs = np.abs(fftshift(fft2(rts_wimage)))
# Create log-polar transformed FFT mag images and register
shape = image_fs.shape
radius = shape[0] // 8 # only take lower frequencies
warped_image_fs = warp_polar(image_fs,
radius=radius,
image = io.imread("images/sample.jpg")
image_gray = rgb2gray(image)
fig, axes = plt.subplots(3, 5, figsize=(16, 9))
fig.suptitle('Increase in value of Sigma(σ) --------->')
sigma = 1
#LoG
#gaussian filter with sigma value as second arguement
img_g = gaussian(image_gray, sigma)
#laplacian
img_log = laplace(img_g, ksize=3, mask=None)
#DoG
sigma2 = sigma * sqrt(2)
img_dog = difference_of_gaussians(image_gray, sigma, sigma2)
axes[0, 0].imshow(image)
axes[0, 0].set_title('Image')
axes[1, 0].imshow(img_log)
axes[1, 0].set_title('LoG, σ = 1')
axes[2, 0].imshow(img_dog)
axes[2, 0].set_title('DoG, σ1 = 1, σ2 = √2')
sigma = 0.1
y= 1
#threshold part: edge detection
while sigma < 1.7:
img_g = gaussian(image_gray, sigma)
# laplacian
img_log = laplace(img_g, ksize=3, mask=None)
def frequency_filters(img,filter):
rows, cols = img.shape
crow, ccol = int(rows / 2), int(cols / 2) # center
fft = cv2.dft(np.float32(img), flags=cv2.DFT_COMPLEX_OUTPUT)
fft_shift = np.fft.fftshift(fft)
if filter == 'lp':
# Circular LPF mask, center circle is 1, remaining all zeros
mask = np.zeros((rows, cols, 2), np.uint8)
r = 80
center = [crow, ccol]
x, y = np.ogrid[:rows, :cols]
mask_area = (x - center[0]) ** 2 + (y - center[1]) ** 2 <= r*r
mask[mask_area] = 1
# apply mask and inverse FFT
fshift = fft_shift * mask
fshift_mask_mag = 2000 * np.log(cv2.magnitude(fshift[:, :, 0], fshift[:, :, 1]))
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img = cv2.magnitude(img_back[:, :, 0], img_back[:, :, 1])
elif filter == 'hp':
# Circular HPF mask, center circle is 0, remaining all ones
mask = np.ones((rows, cols, 2), np.uint8)
r = 150
center = [crow, ccol]
x, y = np.ogrid[:rows, :cols]
mask_area = (x - center[0]) ** 2 + (y - center[1]) ** 2 <= r*r
# apply mask and inverse FFT
fshift = fft_shift * mask
fshift_mask_mag = 50 * np.log(cv2.magnitude(fshift[:, :, 0], fshift[:, :, 1]))
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img = cv2.magnitude(img_back[:, :, 0], img_back[:, :, 1])
elif filter == 'bp':
# Concentric BPF mask,with are between the two cerciles as one's, rest all zero's.
mask = np.zeros((rows, cols, 2), np.uint8)
r_out = 80
r_in = 5
center = [crow, ccol]
x, y = np.ogrid[:rows, :cols]
mask_area = np.logical_and(((x - center[0]) ** 2 + (y - center[1]) ** 2 >= r_in ** 2),
((x - center[0]) ** 2 + (y - center[1]) ** 2 <= r_out ** 2))
mask[mask_area] = 1
# apply mask and inverse FFT
fshift = fft_shift * mask
fshift_mask_mag = 2000 * np.log(cv2.magnitude(fshift[:, :, 0], fshift[:, :, 1]))
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img = cv2.magnitude(img_back[:, :, 0], img_back[:, :, 1])
elif filter == 'bp-1':
wimage = img * window('hann', img.shape) # window image to improve FFT
filtered_image = difference_of_gaussians(img, 1, 1)
filtered_wimage = filtered_image * window('hann', img.shape)
im_f_mag = fftshift(np.abs(fftn(wimage)))
fim_f_mag = fftshift(np.abs(fftn(filtered_wimage)))
img = filtered_image
elif filter == 'bp-2':
wimage = img * window('hann', img.shape) # window image to improve FFT
filtered_image = difference_of_gaussians(img, 10)
filtered_wimage = filtered_image * window('hann', img.shape)
im_f_mag = fftshift(np.abs(fftn(wimage)))
fim_f_mag = fftshift(np.abs(fftn(filtered_wimage)))
img = filtered_image
return cv2.normalize(img,None,0,255,cv2.NORM_MINMAX,dtype=cv2.CV_8U )
# Demonstration
# define path of the test set
test_path = os.path.dirname(dirname(
realpath(__file__))) + '\BIC Project\images'
# import test set
test_set = images_import(test_path)
# display example image
import matplotlib.pyplot as plt
plt.imshow(test_set[0], cmap='gray')
plt.show()
# apply DoG filter
dog = difference_of_gaussians(test_set[0], 1.5)
# display example image after filter
plt.imshow(dog, cmap='gray')
plt.show()
# temporal encoding example
window = 5
layers = 1
temp_test = temporal_encoding(dog, window, layers)
for i in range(window):
plt.imshow(temp_test[:, :, i], cmap='Greys')
plt.show()
img.seek(I)
imgArray[:, :, I] = np.asarray(img)
img.close()
return (imgArray)
data = loadtiffs('test.tif')
data = data.squeeze()
outb = sk.gaussian(data, 10)
outs = sk.gaussian(data, 1)
plt.subplot(2, 2, 1)
plt.imshow(data)
plt.subplot(2, 2, 2)
plt.imshow(outb)
plt.subplot(2, 2, 3)
plt.imshow(outs)
plt.subplot(2, 2, 4)
plt.imshow(outs - outb)
plt.show()
outd = sk.difference_of_gaussians(data, 1, 10)
plt.imshow(outd)
plt.show()
def enhance_edges(im):
im_edge_enh = difference_of_gaussians(im, 1.5, multichannel=False) * 100#, mode='constant', cval=1)
#im_edge_enh = cv2.normalize(im_edge_enh,None,alpha=0,beta=255, norm_type=cv2.NORM_MINMAX).astype('uint8')
im_edge_enh = exposure.rescale_intensity(im_edge_enh.astype('int8'), out_range=(0,255)).astype('uint8')
return im_edge_enh
img_paths = glob.glob(
"D:/Datasets/PlantVillage/Pepper__bell___Bacterial_spot/*.JPG")
r = 50
N = 3
for path in img_paths:
img = cv.imread(path)
img = cv.cvtColor(img, cv.COLOR_BGR2RGB)
svd_decolor = TruncSVDdecolor(img, r)
svd_decolor = ndimage.convolve(svd_decolor, np.ones((N, N)) / (N * N))
# print(np.unique(svd_decolor))
hue = cv.cvtColor(img, cv.COLOR_RGB2HSV)[:, :, 0]
hue = filters.difference_of_gaussians(hue, low_sigma=4, high_sigma=5)
# print(np.unique(hue))
exr_img = apply_ExR(img)
exr_img = ndimage.convolve(exr_img, np.ones((N, N)) / (N * N))
# print(np.unique(exr_img))
accf = (0.1 * exr_img) + svd_decolor + hue
accf = accf * 0.5
# accf_bin = accf < filters.threshold_mean(accf)
plt.subplot(221)
plt.title("SVD Decolor")
plt.axis('off')
plt.imshow(svd_decolor, cmap='gray')
plt.subplot(222)
def test_dog_invalid_sigma2():
image = np.ones((3, 3))
with pytest.raises(ValueError):
difference_of_gaussians(image, 3, 2)
with pytest.raises(ValueError):
difference_of_gaussians(image, (1, 5), (2, 4))
y, x, r = blob
c = plt.Circle((x, y), r, color='lime', linewidth=1, fill=False)
ax.add_patch(c)
# plt.imshow(mask, cmap = plt.cm.gray)
# plt.figure()
# n, bins, patches = plt.hist(blobs_log[:, 2])
#############
# LABEL DETECTION
#############
#dilate to avoid loosing small elements on edges
#image_dil = dilation(stars_gray, np.ones((5,5)))
#make the image smooth
#image_gauss = gaussian(stars_gray, sigma=1.5)
#automatic threshold
stars_filtered = difference_of_gaussians(stars_gray, low_sigma=1, high_sigma=7)
#print("mean values : " ,stars_gray.mean())
#find contour
contours = find_contours(stars_filtered, level=0.1)
# Display the image and plot all contours found
fig_c, ax_c = plt.subplots()
ax_c.imshow(stars_gray, interpolation='nearest', cmap=plt.cm.gray)
for n, contour in enumerate(contours):
ax_c.plot(contour[:, 1], contour[:, 0], linewidth=1)
print("Number of contours counted : ", len(contours))
ax_c.axis('image')
ax_c.set_xticks([])
ax_c.set_yticks([])
plt.show()
