def load_image():
'''Loads the airplane and Brussels Image'''
#Image Path
img1_path = "/home/harshbhate/Pictures/airplane_downsample_gray_square.jpg"
img2_path = "/home/harshbhate/Pictures/brussels_downsample_gray_square.jpg"
#Read Image
IMG1 = dip.image_io.im_read(img1_path)
IMG2 = dip.image_io.im_read(img2_path)
#Convert to float
IMG1 = dip.im_to_float(IMG1)
IMG2 = dip.im_to_float(IMG2)
#Normalize
IMG1 *= 255
IMG2 *= 255
#Return
return [IMG1, IMG2]
def sharpen(im, kernel):
if im.dtype != np.uint8:
print('Fix data type to uint8')
return
#Convert to float and scale to 255
im = dip.im_to_float(im)
im *= 255
im_lap = im
im_lap = dip.convolve2d(im_lap, kernel)
# Shift up to remove negative values
im_lap = im_lap - np.min(im_lap)
# Rescale to range of integers
im_lap = 255 * (im_lap / np.max(im_lap))
#crop to original size
im_lap = dip.resample(im_lap, np.array([[1, 0], [0, 1]]), crop=True, crop_size=(im.shape[0], im.shape[1]))
# Add laplacian back in, normalize, convert to uint8
im_n = im + im_lap
im_n = im_n - np.min(im_n)
im_n = 255 * im_n / np.max(im_n)
im_n = im_n.astype(np.uint8)
im_lap = im_lap.astype(np.uint8)
return im_n, im_lap
def fast_multiplicative_restore(self,
degraded_image,
h_param=35,
search_window_size=51):
int_image = dip.float_to_im(degraded_image)
return dip.im_to_float(
cv2.fastNlMeansDenoising(int_image,
h=h_param,
searchWindowSize=search_window_size))
def param_search_multiplicative_restore(self, degraded_image,
original_image):
int_image = dip.float_to_im(degraded_image)
psnr_max = None
best_denoise = None
for i in range(1, 25):
cur_denoised = dip.im_to_float(
cv2.fastNlMeansDenoising(int_image, h=i, searchWindowSize=31))
cur_psnr = dip.PSNR(original_image, cur_denoised)
if psnr_max is None or cur_psnr > psnr_max:
best_denoise = cur_denoised
psnr_max = cur_psnr
return best_denoise
def basic_image_ip(im_path, args, convert_to_float = True, normalize = True):
'''Function to read image, convert to float and normalize'''
if (os.path.exists(im_path)):
X = dip.image_io.im_read(im_path)
else:
print (bcolors.FAIL+"File Path not found, aborting!"+bcolors.ENDC)
sys.exit()
if args.verbose:
print (bcolors.OKGREEN+"Converted Image to Float"+bcolors.ENDC)
if (convert_to_float):
X = dip.im_to_float(X)
if (convert_to_float and normalize):
if args.verbose:
print ("Normalizing")
X *= 255
return X
def load_image(args, convert_to_float=True, normalize=True):
'''Loading the image and converting to float'''
if args.verbose:
msg1 = bcolors.OKBLUE + "Loading the image, converting to float and normalizing" + bcolors.ENDC
msg2 = bcolors.OKBLUE + "Loading the image, converting to float" + bcolors.ENDC
msg3 = bcolors.OKBLUE + "Loading the image" + bcolors.ENDC
if (convert_to_float and normalize):
print(msg1)
elif (convert_to_float and not normalize):
print(msg2)
else:
print(msg3)
if (os.path.exists(args.path)):
X = dip.image_io.im_read(args.path)
else:
print(bcolors.FAIL + "File Path not found, aborting!" + bcolors.ENDC)
sys.exit()
if (convert_to_float):
X = dip.im_to_float(X)
if (convert_to_float and normalize):
X *= 255
return X
def open_image(file):
three_layer_image = dip.im_to_float(dip.im_read(file))
return np.dot(three_layer_image[..., :3], [0.2989, 0.5870, 0.1140])
Problem Number: 2 """ import dippykit as dip import numpy as np picture_link = "/home/harshbhate/Pictures/cameraman.tif" save_link_1 = "/home/harshbhate/Pictures/cameraman_add.tif" save_link_2 = "/home/harshbhate/Pictures/cameraman_square.tif" save_link_3 = "/home/harshbhate/Pictures/cameraman_fourier.tif" #(c) Reading an image X = dip.im_read(picture_link) #(d) Converting the image to normalized floating point space X = dip.im_to_float(X) X *= 255 #(e) Adding Constant to Image Y = X + 75 #(f) Renormalize the image and covert to integer Y = dip.float_to_im(Y/255) #(g) Writing an image to disk dip.im_write(Y, save_link_1) #(h) Square Intenstiy and write image to disk Z = X**2 Z = dip.float_to_im(Z/255) Z = dip.im_write(Z, save_link_2)
def run_optical_flow(filepath_ind: int, OF_alg: int, param: int=100,
display: bool=True):
frame_1 = dip.im_read(filepaths[filepath_ind] + 'frame1.png')[:, :, :3]
frame_2 = dip.im_read(filepaths[filepath_ind] + 'frame2.png')[:, :, :3]
residual = np.abs(frame_1.astype(float) - frame_2.astype(float)) \
.astype(np.uint8)
frame_1_gray = dip.rgb2gray(frame_1)
frame_2_gray = dip.rgb2gray(frame_2)
PSNR_val = dip.PSNR(frame_1_gray, frame_2_gray)
if display:
# Plot the initial images
dip.figure()
dip.subplot(1, 3, 1)
dip.imshow(frame_1)
dip.title('Frame 1', fontsize='x-small')
dip.subplot(1, 3, 2)
dip.imshow(frame_2)
dip.title('Frame 2', fontsize='x-small')
dip.subplot(1, 3, 3)
dip.imshow(residual)
dip.title('Residual - PSNR: {:.2f} dB'.format(PSNR_val), fontsize='x-small')
# Convert to grayscale for analysis
frame_1 = dip.im_to_float(frame_1_gray)
frame_2 = dip.im_to_float(frame_2_gray)
start_time = default_timer()
# ============================ EDIT THIS PART =============================
mask_x = np.array([[-1, 1], [-1,1]])
mask_y = np.array([[-1, -1], [1,1]])
mask_t_2 = np.array([[-1, -1], [-1,-1]])
mask_t_1 = np.array([[1, 1], [1,1]])
dIx = dip.convolve2d(frame_1, mask_x, mode='same', like_matlab=True)
dIy = dip.convolve2d(frame_1, mask_y, mode='same', like_matlab=True)
dIt = dip.convolve2d(frame_1, mask_t_1, mode='same', like_matlab=True) + dip.convolve2d(frame_2, mask_t_2, mode='same', like_matlab=True)
# ==========!!!!! DO NOT EDIT ANYTHING BELOW THIS !!!!!====================
# Instantiate blank u and v matrices
u = np.zeros_like(frame_1)
v = np.zeros_like(frame_1)
if 0 == OF_alg:
print('The optical flow is estimated using Horn-Schuck...')
u, v = horn_schuck(u, v, dIx, dIy, dIt, param)
elif 1 == OF_alg:
print('The optical flow is estimated using Lucas-Kanade...')
u, v = lucas_kanade(u, v, dIx, dIy, dIt, param)
else:
raise ValueError('OF_alg must be either 0 or 1')
end_time = default_timer()
# Determine run time
duration = end_time - start_time
clock = [int(duration // 60), int(duration % 60)]
print('Flow estimation time was {} minutes and {} seconds'
.format(*clock))
# Downsample for better visuals
stride = 10
m, n = frame_1.shape
x, y = np.meshgrid(range(n), range(m))
x = x.astype('float64')
y = y.astype('float64')
# Downsampled u and v
u_ds = u[::stride, ::stride]
v_ds = v[::stride, ::stride]
# Coords for downsampled u and v
x_ds = x[::stride, ::stride]
y_ds = y[::stride, ::stride]
# Estimated flow
estimated_flow = np.stack((u, v), axis=2)
# Read file for ground truth flow
ground_truth_flow = read_flow_file(filepaths[filepath_ind] + 'flow1_2.flo')
u_gt_orig = ground_truth_flow[:, :, 0]
v_gt_orig = ground_truth_flow[:, :, 1]
u_gt = np.where(np.isnan(u_gt_orig), 0, u_gt_orig)
v_gt = np.where(np.isnan(v_gt_orig), 0, v_gt_orig)
# Downsampled u_gt and v_gt
u_gt_ds = u_gt[::stride, ::stride]
v_gt_ds = v_gt[::stride, ::stride]
if display:
# Plot the optical flow field
dip.figure()
dip.subplot(2, 2, 1)
dip.imshow(frame_2, 'gray')
dip.quiver(x_ds, y_ds, u_ds, v_ds, color='r')
dip.title('Estimated', fontsize='x-small')
dip.subplot(2, 2, 2)
dip.imshow(frame_2, 'gray')
dip.quiver(x_ds, y_ds, u_gt_ds, v_gt_ds, color='r')
dip.title('Ground truth', fontsize='x-small')
# Draw colored velocity flow maps
dip.subplot(2, 2, 3)
dip.imshow(flow_to_color(estimated_flow))
dip.title('Estimated', fontsize='x-small')
dip.subplot(2, 2, 4)
dip.imshow(flow_to_color(ground_truth_flow))
dip.title('Ground truth', fontsize='x-small')
# Normalization for metric computations
normalize = lambda im: (im - np.min(im)) / (np.max(im) - np.min(im))
un = normalize(u)
un_gt = normalize(u_gt)
un_gt[np.isnan(u_gt_orig)] = 1
vn = normalize(v)
vn_gt = normalize(v_gt)
vn_gt[np.isnan(v_gt_orig)] = 1
# Error calculations and displays
EPE = ((un - un_gt) ** 2 + (vn - vn_gt) ** 2) ** 0.5
AE = np.arccos(((un * un_gt) + (vn * vn_gt) + 1) /
(((un + vn + 1) * (un_gt + vn_gt + 1)) ** 0.5))
EPE_nan_ratio = np.sum(np.isnan(EPE)) / EPE.size
AE_nan_ratio = np.sum(np.isnan(AE)) / AE.size
EPE_inf_ratio = np.sum(np.isinf(EPE)) / EPE.size
AE_inf_ratio = np.sum(np.isinf(AE)) / AE.size
print('Error nan ratio: EPE={:.2f}, AE={:.2f}'
.format(EPE_nan_ratio, AE_nan_ratio))
print('Error inf ratio: EPE={:.2f}, AE={:.2f}'
.format(EPE_inf_ratio, AE_inf_ratio))
EPE_avg = np.mean(EPE[~np.isnan(EPE)])
AE_avg = np.mean(AE[~np.isnan(AE)])
print('EPE={:.2f}, AE={:.2f}'.format(EPE_avg, AE_avg))
if display:
dip.show()
return clock, EPE_avg, AE_avg
import dippykit as dip
import numpy as np
# Part (a)
I1 = dip.im_read('/home/harshbhate/Pictures/lena.png') # Specify your image here
I1 = dip.im_to_float(I1) #Converting image to float
I1 *= 255 #Normalizing
# Part (b)
# Take the Fourier transform of the image
H1 = dip.fft2(I1) # Fourier transform of I1
H1 = dip.fftshift(H1)
H1 = np.log(np.abs(H1))
print ("Shape of I1:"+str(I1.shape))
print("Shape of H1"+str(H1.shape))
# Part (c)
# Downsample the image by 2 in both directions (and take its Fourier transform)
x_scaling = 2
y_scaling = 2
sampling_matrix = np.array([[x_scaling, 0],[0, y_scaling]])
I2 = dip.sampling.resample(I1, sampling_matrix) # Downsampled I1
H2 = dip.fft2(I2) # Fourier transform of I2
# Part (d)
# Pad the downsampled image's spectrum (H2) with zeros and then take its
# inverse Fourier transform
H3 = np.pad(H2,(128, 128), 'constant', constant_values = (0,0)) # Zero-padded H2
I3 = np.abs(dip.ifft2(H3)) # Interpolated image
I3 = I3/(np.amax(I3))*255 #Normalizing
#Converting everything back to int and normalizing
I1 = dip.float_to_im(I1/255)
I2 = dip.float_to_im(I2/255)
def read_image(img_path):
'''Function to read image, convert to float and normalize'''
X = dip.image_io.im_read(img_path)
X = dip.im_to_float(X)
X *= 255
return X
def open_image_file_as_matrix(self, image_path):
im = dip.im_read(image_path)
float_im = dip.im_to_float(im)
gray_im = self.rgb_to_gray(float_im)
return gray_im
import dippykit as dip
import numpy as np
import matplotlib.pyplot as plt
import os
path = "/Users/chuchu/Dropbox/gt_exp/ddb1_fundusimages/" # Change the path to where you store the images
modes = [2, 3, 4]
for m in range(len(modes)):
dir = 'upsample_img/'+str(modes[m]);
if not os.path.exists(dir):
os.makedirs(dir)
for m in range(len(modes)):
for filename in os.listdir(path):
mode = modes[m]
file_path = path + filename
f = dip.im_read(file_path) # read icmage
f = dip.im_to_float(f)
M = np.array([[1/mode, 0],
[0, 1/mode]])
f_up_0 = dip.sampling.resample(f[:,:,0], M, interp= 'bilinear')
f_up_1 = dip.sampling.resample(f[:, :, 1], M, interp='bilinear')
f_up_2 = dip.sampling.resample(f[:, :, 2], M, interp='bilinear')
h, l = f_up_0.shape
f_up = np.zeros((h, l, 3))
f_up[:,:,0] = f_up_0
f_up[:, :, 1] = f_up_1
f_up[:, :, 2] = f_up_2
upsample_img = 'upsample_img/' + str(mode)+ '/' +filename[:-4] + '_up' + str(mode) + '.jpg'
save_im = dip.float_to_im(f_up)
dip.im_write(save_im, upsample_img)
import dippykit as dip
from math import exp
import numpy as np
# Proof of concept low pass filter
dim_filter = 800
h = np.zeros((dim_filter, dim_filter))
for u in range(dim_filter):
for v in range(dim_filter):
h[u][v] = exp(-(u + v) / (dim_filter * 0.3))
# Loading image
im = dip.im_read('images/UW_400.png')
im = dip.im_to_float(im)
if 2 < im.ndim:
im = np.mean(im, axis=2)
F = dip.fft2(im)
print(h * F)
#Plot results
#Original spectra
dip.figure(1)
dip.subplot(2, 2, 1)
dip.imshow(im, 'gray')
dip.title('Original Image')
## Define Down Sampling Matrix
D = 8
Down_Sampled_Matrix = np.array([[D, 0], [0, D]])
# Generate Training Set
Training_images = np.zeros([100, 64, 64])
Training_labels = np.zeros([100, 1])
if mode == 0:
for i in range(50):
path1 = "Tumor_Images/" + str(i + 1) + ".png"
path2 = "Non_Tumor_Images/" + str(i + 1) + ".png"
Training_images[i, :, :] = dip.resample(
dip.im_to_float(dip.im_read(path1)), Down_Sampled_Matrix)
Training_images[i + 50, :, :] = dip.resample(
dip.im_to_float(dip.im_read(path2)), Down_Sampled_Matrix)
Training_labels[i] = 1
Training_labels[i + 50] = 0
elif mode == 1:
for i in range(50):
path1 = "Tumor_Images/" + str(i + 1) + ".png"
path2 = "Non_Tumor_Images/" + str(i + 1) + ".png"
X1 = SkullAndShape(cv2.imread(path1))
X2 = SkullAndShape(cv2.imread(path1))
def multiplicative_clustering_restore(self, degraded_image):
block_size = 16
max_h_value = 30
blocks = self.break_image_into_blocks(degraded_image, block_size)
variances = self.get_variances_of_blocks(blocks)
medians = self.get_statistic_of_blocks(blocks, np.median)
means = self.get_means_of_blocks(blocks)
maxs = self.get_statistic_of_blocks(blocks,
lambda b: np.percentile(b, 55))
mins = self.get_statistic_of_blocks(blocks,
lambda b: np.percentile(b, 45))
scaler = preprocessing.StandardScaler()
data = []
for i in range(len(blocks)):
data.append([
variances[i],
np.abs(medians[i] - means[i]), maxs[i] * 1.3, mins[i] * 1.3
])
scaler.fit(data)
output_image = np.zeros(
[degraded_image.shape[0], degraded_image.shape[1]])
cluster_image = np.zeros(
[degraded_image.shape[0], degraded_image.shape[1]])
h_param_image = np.zeros(degraded_image.shape)
ch = ClusteringHandler(data)
ch.cluster_data()
clustered_labels = ch.labels
cluster_centers = np.asarray(ch.cluster_centers)
diff_c = cluster_centers[:, 2] - cluster_centers[:, 3]
mean_c = cluster_centers[:, 1]
median_c = cluster_centers[:, 1]
var_centers = cluster_centers[:, 0]
average_var = np.mean(var_centers)
h_params = np.linspace(max_h_value, max_h_value, ch.num_clusters)
window_sizes = [21 for i in range(ch.num_clusters)]
count = 0
h_params = [
a for _, a in sorted(zip(var_centers, h_params), reverse=True)
]
h_params = var_centers**.5 * diff_c**.55 * 20 * 25 * 23 * 30 * 15 / 30 / 300
for m in range(0, degraded_image.shape[0], block_size):
for n in range(0, degraded_image.shape[1], block_size):
cur_percentile = clustered_labels[
m // block_size * (degraded_image.shape[0] // block_size) +
(n // block_size)]
cluster_image[m:m + block_size, n:n +
block_size] = cur_percentile / ch.num_clusters
h_param_image[m:m + block_size,
n:n + block_size] = h_params[cur_percentile]
# dip.im_write(dip.float_to_im(h_param_image / np.max(h_param_image)), "./unsmoothed_hparams.jpg")
h_param_image = self.blur_borders(h_param_image, cluster_image)
# dip.im_write(dip.float_to_im(h_param_image / np.max(h_param_image)), "./smoothed.jpg")
h_param_count = 0
all_temp_outputs = []
h_param_list = np.unique(h_param_image.flatten())
processes = []
manager = Manager()
return_dict = manager.dict()
blocked_pad_size = 32
blocked_image = self.create_surrounding_block_fast(
degraded_image, pad_width=blocked_pad_size)
process_count = 0
for c in h_param_list:
temp_output_image = self.fast_multiplicative_restore(
blocked_image, h_param=c, search_window_size=21
)[blocked_pad_size:degraded_image.shape[0] + blocked_pad_size,
blocked_pad_size:degraded_image.shape[1] + blocked_pad_size]
return_dict[c] = temp_output_image
h_param_count += 1
output_image = output_image.flatten()
h_param_image = h_param_image.flatten()
for cur_param in return_dict.keys():
idx = h_param_image == cur_param
return_dict[cur_param] = return_dict[cur_param].flatten()
output_image[idx] = return_dict[cur_param][idx]
return dip.im_to_float(
dip.float_to_im(output_image.reshape(
degraded_image.shape))), cluster_image, h_params