def display_diff(im1, im2):
im_diff = cv2.cvtColor(im1, cv2.COLOR_BGR2GRAY) - cv2.cvtColor(
im2, cv2.COLOR_BGR2GRAY)
dip.figure()
dip.imshow(im_diff)
dip.title('Difference image')
dip.show()
def display_images(images, text):
num = len(images)
dip.figure()
for i in range(num):
dip.subplot(1, num, i + 1)
dip.title(text[i])
dip.imshow(images[i])
dip.show()
def _test_noise_mode(self, file, deg_type):
fh = ImageFileHandler()
im = fh.open_image_file_as_matrix(file)
degraded_im = self.degrade(im, degradation_type=deg_type)
dip.figure()
dip.subplot(121)
dip.imshow(im, cmap="gray")
dip.subplot(122)
dip.imshow(degraded_im, cmap="gray")
dip.xlabel("PSNR: {0:.2f}".format(dip.PSNR(im, degraded_im)))
dip.show()
def dft(args):
'''Compute and show DFT of image'''
X = basic_image_ip(IMAGE_PATH, args)
if args.verbose:
print (X.shape)
fX = dip.fft2(X)
fX = dip.fftshift(fX)
fX = np.log(np.abs(fX))
if args.verbose:
print ("Done with FFT")
dip.imshow(fX)
dip.show()
def show_image(IMG, IMG_DCT, IMG_DIFF, IMG_RECONS):
'''Function to display image'''
IMG = floater(IMG)
IMG_DCT = floater(IMG_DCT)
IMG_DIFF = floater(IMG_DIFF)
IMG_RECONS = floater(IMG_RECONS)
dip.figure()
dip.subplot(2, 2, 1)
dip.imshow(IMG, 'gray')
dip.title('Grayscale Image', fontsize='x-small')
dip.subplot(2, 2, 2)
dip.imshow(IMG_DCT, 'gray')
dip.title('DCT of Image', fontsize='x-small')
dip.subplot(2, 2, 3)
dip.imshow(IMG_DIFF)
dip.colorbar()
dip.title('Error image', fontsize='x-small')
dip.subplot(2, 2, 4)
dip.imshow(IMG_RECONS, 'gray')
dip.title('Reconstructed Image', fontsize='x-small')
dip.show()
def float_image_op(IMG, save_path, args, downsample = True):
'''Function to display and save an float image'''
IMG = dip.float_to_im(IMG/255)
if downsample:
save_path = os.path.join (SAVE_PATH, DOWNSAMPLE_DIR,save_path)
else:
save_path = os.path.join (SAVE_PATH, UPSAMPLE_DIR,save_path)
dip.image_io.im_write(IMG, save_path)
if args.verbose:
if downsample:
print ("Downsampled Image is saved")
else:
print ("Upsampled Image is saved")
dip.imshow(IMG)
dip.show()
def _test_restore_mode(self, file, deg_type, save_images=False, name=None):
fh = ImageFileHandler()
im_degrader = ImageDegrader()
im = fh.open_image_file_as_matrix(file)
degraded_im = im_degrader.degrade(im,
degradation_type=deg_type,
severity_value=.5)
restored_im, clustered_im, h_params = self.multiplicative_clustering_restore(
degraded_im)
restored_im_2 = self.fast_multiplicative_restore(
degraded_im, h_param=np.mean(h_params), search_window_size=21)
if save_images:
dip.im_write(dip.float_to_im(degraded_im),
"./" + name + "_degraded_image.jpg",
quality=95)
dip.im_write(dip.float_to_im(restored_im),
"./" + name + "_restored_image.jpg",
quality=95)
dip.im_write(dip.float_to_im(clustered_im),
"./" + name + "_clustered_image.jpg",
quality=95)
dip.figure()
dip.subplot(141)
dip.imshow(im, cmap="gray")
dip.subplot(142)
dip.imshow(degraded_im, cmap="gray")
dip.xlabel("PSNR: {0:.2f}, SSIM: {1:.2f}".format(
dip.PSNR(im, degraded_im),
dip.SSIM(im, degraded_im)[0]))
dip.subplot(143)
dip.imshow(restored_im, cmap="gray")
dip.xlabel("PSNR: {0:.2f}, SSIM: {1:.2f}".format(
dip.PSNR(im, restored_im),
dip.SSIM(im, restored_im)[0]))
dip.subplot(144)
dip.imshow(restored_im_2, cmap="gray")
dip.xlabel("PSNR: {0:.2f}, SSIM: {1:.2f}".format(
dip.PSNR(im, restored_im_2),
dip.SSIM(im, restored_im_2)[0]))
dip.show()
def display_image(IMAGES):
'''Display the Images and save'''
IMAGES = [dip.float_to_im(IMG / 255) for IMG in IMAGES]
dip.figure()
dip.subplot(2, 2, 1)
dip.imshow(IMAGES[0], 'gray')
dip.title('Airplane Original Image')
dip.subplot(2, 2, 2)
dip.imshow(IMAGES[1], 'gray')
dip.title('Brussels Original Image')
dip.subplot(2, 2, 3)
dip.imshow(IMAGES[2], 'gray')
dip.title('Reconstructed Airplane Image')
dip.subplot(2, 2, 4)
dip.imshow(IMAGES[3], 'gray')
dip.title('Reconstructed Brussels Image')
dip.show()
def display_image(args, IMAGES):
'''Display a float image and save'''
if args.verbose:
msg = bcolors.OKBLUE + "Displaying and saving the image" + bcolors.ENDC
name = "lena_interp.png"
IMAGES = [dip.float_to_im(IMG / 255) for IMG in IMAGES]
dip.figure()
dip.subplot(2, 2, 1)
dip.imshow(IMAGES[0], 'gray')
dip.title('Original Image')
dip.subplot(2, 2, 2)
dip.imshow(IMAGES[1], 'gray')
dip.title('Interpolated Image')
dip.subplot(2, 2, 3)
dip.imshow(IMAGES[2], 'gray')
dip.title('Reconstructed Image')
dip.subplot(2, 2, 4)
dip.imshow(IMAGES[3], 'gray')
dip.title('Difference Image')
dip.show()
PSNR_mild = dip.metrics.PSNR(dip.float_to_im(X / 255),
dip.float_to_im(extEdgeMildX / 255))
PSNR_severe = dip.metrics.PSNR(dip.float_to_im(X / 255),
dip.float_to_im(extEdgeSevereX / 255))
#Displaying PSNR Output
print("\n\tPSNR for extended Laplacian with minor blurring is %.2f" %
PSNR_minor)
print("\n\tPSNR for extended Laplacian with mild blurring is %.2f" % PSNR_mild)
print("\n\tPSNR for extended Laplacian with severe blurring is %.2f" %
PSNR_severe)
#Image Output
dip.figure()
dip.subplot(3, 4, 1)
dip.imshow(X, 'gray')
dip.title('Original Image', fontsize='x-small')
dip.subplot(3, 4, 2)
dip.imshow(minorX, 'gray')
dip.title('Minor Blurring', fontsize='x-small')
dip.subplot(3, 4, 3)
dip.imshow(mildX, 'gray')
dip.title('Mild Blurring', fontsize='x-small')
dip.subplot(3, 4, 4)
dip.imshow(severeX, 'gray')
dip.title('Severe Blurring', fontsize='x-small')
dip.subplot(3, 4, 5)
dip.imshow(edgeMinorX, 'gray')
dip.title('Laplacian on Minor Blurring', fontsize='x-small')
dip.subplot(3, 4, 6)
dip.imshow(edgeMildX, 'gray')
yy = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])
Gx = signal.convolve2d(img, xx, boundary='symm', mode='same')
Gy = signal.convolve2d(img, yy, boundary='symm', mode='same')
Igradient_fd = 5
featureimg_total = np.zeros((r, c, Igradient_fd))
featureimg_total[:, :, 0] = img
featureimg_total[:, :, 1] = Gx
featureimg_total[:, :, 2] = np.abs(Gx)
featureimg_total[:, :, 3] = Gy
featureimg_total[:, :, 4] = np.abs(Gy)
Igradient_fd = 5
for j in np.arange(Igradient_fd):
featureimg = featureimg_total[:, :, j]
dfeatureimg = featureimg.astype('double')
itimg = np.cumsum(featureimg, axis=0)
# dip.imshow(itimg,'gray')
# dip.show()
# cv2.imshow('imshow2',itimg/8)
itimg = np.cumsum(itimg, axis=1)
iimg = np.zeros((itimg.shape[0] + 2, itimg.shape[1] + 2))
iimg[1:-1, 1:-1] = itimg
dip.imshow(iimg, 'gray')
dip.show()
# dip.imshow(featureimg_total[:,:,j],'gray')
# dip.show()
# cv2.imshow('imshow1',itimg/8)
# cv2.imshow('imshow0',featureimg_total[:,:,j]/8)
cv2.waitKey(0)
cv2.destroyAllWindows()
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
# 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)
I3 = dip.float_to_im(I3/255)
H2 = dip.fftshift(H2)
H2 = np.log(np.abs(H2))
H3 = np.pad(H2,(128, 128), 'constant', constant_values = (0,0))
# Plotting
dip.figure()
dip.subplot(2, 3, 1)
dip.imshow(I1, 'gray')
dip.title('Original Image')
dip.subplot(2, 3, 2)
dip.imshow(I2, 'gray')
dip.title('Downsampled Image')
dip.subplot(2, 3, 3)
dip.imshow(I3, 'gray')
dip.title('Interpolated image')
dip.subplot(2, 3, 4)
dip.imshow(H1, 'gray')
dip.title('Spectrum of Original Image')
dip.subplot(2, 3, 5)
dip.imshow(H2, 'gray')
dip.title('Spectrum of Downsampled Image')
dip.subplot(2, 3, 6)
dip.imshow(H3, 'gray')
return X_rec
#X = dip.im_read('airplane_downsample_gray_square.jpg')
X = dip.im_read('brussels_gray_square.jpg')
X_hat_1 = KLT_blocks(X, 1, 10)
X_hat_12 = KLT_blocks(X, 12, 10)
X_hat_24 = KLT_blocks(X, 24, 10)
diff_1 = X - X_hat_1
diff_12 = X - X_hat_12
diff_24 = X - X_hat_24
dip.figure(1)
dip.subplot(2, 2, 1)
dip.imshow(X, 'gray')
dip.title('Original')
dip.subplot(2, 2, 2)
dip.imshow(X_hat_1, 'gray')
dip.title('k = 1')
dip.subplot(2, 2, 3)
dip.imshow(X_hat_12, 'gray')
dip.title('k = 12')
dip.subplot(2, 2, 4)
dip.imshow(X_hat_24, 'gray')
dip.title('k = 24')
dip.figure(2)
dip.subplot(1, 3, 1)
dip.imshow(diff_1, 'gray')
dip.colorbar()
# STEP 1: Loading the image
# ============================ EDIT THIS PART =================================
im = dip.image_io.im_read(img_path)
# STEP 2: Converting to YCrCb
# ============================ EDIT THIS PART =================================
im = dip.utilities.rgb2ycbcr(im) # HINT: Look into dip.rgb2ycbcr
# STEP 3: Keep only the luminance channel
# ============================ EDIT THIS PART =================================
im = im[:,:,0]
# ===================!!!!! DO NOT EDIT THIS PART !!!!!=========================
dip.figure()
dip.subplot(2, 2, 1)
dip.imshow(im, 'gray')
dip.title('Grayscale image', fontsize='x-small')
# STEP 4: Calculating the image entropy
# ============================ EDIT THIS PART =================================
H = dip.metrics.entropy(im)
# ===================!!!!! DO NOT EDIT THIS PART !!!!!=========================
print("Entropy of the grayscale image = {:.2f} bits/pixel".format(H))
# STEP 5: Coding of the original image
# ============================ EDIT THIS PART =================================
byte_seq, _,_,_ = dip.coding.huffman_encode(im.flatten())
l,b = im.shape
im_bit_rate = (len(byte_seq)*8.0)/float(l*b)
# ===================!!!!! DO NOT EDIT THIS PART !!!!!=========================
im_gaussian = dip.image_noise(im, "gaussian")
im_poisson = dip.image_noise(im, "poisson")
im_salt_pepper = dip.image_noise(im, "s&p")
im_speckle = dip.image_noise(im, "speckle")
# Compute the SSIM values and images
# ============================ EDIT THIS PART =============================
mssim_gaussian, ssim_image_gaussian = dip.metrics.SSIM(im, im_gaussian)
mssim_poisson, ssim_image_poisson = dip.metrics.SSIM(im, im_poisson)
mssim_salt_pepper, ssim_image_salt_pepper = dip.metrics.SSIM(
im, im_salt_pepper)
mssim_speckle, ssim_image_speckle = dip.metrics.SSIM(im, im_speckle)
dip.figure()
dip.subplot(2, 4, 1)
dip.imshow(im_gaussian, 'gray')
dip.title('Distortion type: gaussian', fontsize='x-small')
dip.subplot(2, 4, 2)
dip.imshow(im_poisson, 'gray')
dip.title('Distortion type: poisson', fontsize='x-small')
dip.subplot(2, 4, 3)
dip.imshow(im_salt_pepper, 'gray')
dip.title('Distortion type: salt & pepper', fontsize='x-small')
dip.subplot(2, 4, 4)
dip.imshow(im_speckle, 'gray')
dip.title('Distortion type: speckle', fontsize='x-small')
dip.subplot(2, 4, 5)
dip.imshow(ssim_image_gaussian, 'gray')
dip.title('SSIM Map; MSSIM={0:.2f}'.format(mssim_gaussian), fontsize='x-small')
dip.subplot(2, 4, 6)
""" example code, will show a random FITS image """ import numpy as np import dippykit as dip import neowise_api as neo from fits_file import Fits IMAGE_DETAILS = neo.find_params() NAME = IMAGE_DETAILS[0] IMAGE = neo.download_fits(NAME) FITS = Fits(IMAGE, IMAGE_DETAILS) FITS.filter_image() FITS.image = np.clip(FITS.image, np.median(FITS.image), np.max(FITS.image)) FITS.image = np.log(FITS.image - np.median(FITS.image) + 1) FITS.image = np.clip(FITS.image, 0.3 * np.max(FITS.image), np.max(FITS.image)) print(FITS.coordinates()) dip.imshow(FITS.image, cmap='gist_heat') dip.colorbar() dip.show()
print('sharpen3')
print(dip.PSNR(img, sharpen3))
Esharpen1 = scale(img1 - ELap1)
print('Esharpen1')
print(dip.PSNR(img, Esharpen1))
Esharpen2 = scale(img2 - ELap2)
print('Esharpen2')
print(dip.PSNR(img, Esharpen2))
Esharpen3 = scale(img3 - ELap3)
print('Esharpen3')
print(dip.PSNR(img, Esharpen3))
dip.figure(1)
dip.subplot(1, 3, 1)
dip.imshow(img1, 'gray')
dip.title('Minor Distortion')
dip.subplot(1, 3, 2)
dip.imshow(img2, 'gray')
dip.title('Mild Distortion')
dip.subplot(1, 3, 3)
dip.imshow(img3, 'gray')
dip.title('Severe Distortion')
dip.figure(2)
dip.subplot(1, 3, 1)
dip.imshow(Lap1, 'gray')
dip.title('Minor Distortion')
dip.subplot(1, 3, 2)
dip.imshow(Lap2, 'gray')
dip.title('Mild Distortion')
for l in range(SIZE):
xIndex = n - k
yIndex = m - l
if (xIndex < 0):
xIndex = LEN + xIndex
if (yIndex < 0):
yIndex = WIDTH + yIndex
coeff = (k**2 + l**2) / (2 * (sigma**2))
h_kl = np.exp(-coeff)
coeffSum = coeffSum + h_kl
outputSum = outputSum + h_kl * g[xIndex, yIndex]
gaussianImage[n, m] = (outputSum + TEENY) / (coeffSum + TEENY)
#Displaying the Images
dip.figure()
dip.subplot(1, 5, 1)
dip.imshow(f, 'gray')
dip.title('Original Image', fontsize='x-small')
dip.subplot(1, 5, 2)
dip.imshow(g, 'gray')
dip.title('Noised Image', fontsize='x-small')
dip.subplot(1, 5, 3)
dip.imshow(gaussianImage, 'gray')
dip.title('Gaussian Filtering', fontsize='x-small')
#Printing the MSE
mseGaussian = dip.metrics.MSE(f * 255, gaussianImage * 255)
print("\n\tThe MSE for Gaussian Transform is %.2f.\n" % mseGaussian)
#Computing the Sigma Filter
SIZE = 6
p = 40 / 255
TEENY = 0.0000000000001
tmp2 = np.pad(tmp2, ((0, 0), (error_col, error_col), (0, 0)),
'constant',
constant_values=(0, 0))
tmp3 = tmp2[int(tmp2.shape[0] / 2 - 1 - row / 2 +
1):int(tmp2.shape[0] / 2 + row / 2),
int(tmp2.shape[1] / 2 - 1 - col / 2 +
1):int(tmp2.shape[1] / 2 + col / 2), :]
tmp4 = np.clip(tmp3, 0, 1)
return tmp4
#example
filename = 'images/airplane.jpg'
im = dip.im_read(filename)
#downSampling
down_IMG = zoomAndshrink(im, 2.5, 1.0 / 1.7, 27.5 / 180.0 * np.pi)
dip.figure(1)
dip.imshow(down_IMG)
#upSampling
up_IMG = zoomAndshrink_inv(down_IMG, 0.4, 1.7, -27.5 / 180.0 * np.pi, im.shape)
dip.figure(2)
dip.imshow(up_IMG)
#show difference
dip.figure(3)
dip.imshow(im - up_IMG)
#show PSNR
print(dip.PSNR(im, up_IMG))
dip.show()
# 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')
dip.subplot(2, 2, 2)
dip.imshow(np.real(dip.ifft2(F * h)), 'gray')
dip.title('Modified image')
dip.subplot(2, 2, 3)
dip.imshow(abs(np.log(dip.fftshift(F))), 'gray')
dip.title('Original spectra')
dip.subplot(2, 2, 4)
dip.imshow(abs(np.log(dip.fftshift(F) * h)), 'gray')
dip.title('Modified spectra')
dip.show()
#(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) #(i) Compute FFT of X fX = dip.fft2(X) fX = dip.fftshift(fX) fX = np.log(np.abs(fX)) #(j) Save and show the resulting spectrum dip.imshow(fX) dip.show()
pixel_array[p] = avg_pixel_value
if (im_skin[i,j] == [0,0,0]).all():
im_skin_interp[i,j] = pixel_array[0]
if (im_skin[i,j+1] == [0,0,0]).all():
im_skin_interp[i,j+1] = pixel_array[1]
if (im_skin[i+1,j] == [0,0,0]).all():
im_skin_interp[i+1 ,j] = pixel_array[2]
if (im_skin[i+1,j+1] == [0,0,0]).all():
im_skin_interp[i+1,j+1] = pixel_array[3]
#Display only skin-coloured pixels on original image and interpolated skin
"""
%matplotlib inline
dip.imshow(im_skin)
dip.show()
%matplotlib inline
dip.imshow(im_skin_interp)
dip.show()
"""
#COPY PIXELS OF INTERPOLATED SKIN ONTO THE ORIGINAL PICTURE
im_res = np.copy(im_original)
cv2.imwrite('temp_images/mask.png',mask)
