def median_filter(image, kernels, save, dpi, num):
image = util.load_image_RGB(image)
kernels = json.loads(kernels)
# Initialize the median_images as list. Values are assigned on the for-loop
median_images = []
titles_images = []
for k in kernels:
median_images.append(cv.medianBlur(image, k))
titles_images.append(f"Kernel {k}x{k}")
# Copy the arrays with the images generated in the for-loop and adds the
# original noisy image for comparison. Also copies and adds the titles.
plot_images = median_images
plot_images.insert(0, image)
plot_titles = titles_images
plot_titles.insert(0, "Noisy Image")
# Plots the images.
fig = util.plotImages(plot_images,
plot_titles,
show=True,
main_title="Median Filter - cv.medianBlur",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def original_pictures(orig, noisy, save, dpi, num):
orig = util.load_image_RGB(orig)
noisy = util.load_image_RGB(noisy)
fig = util.plotImages([orig, noisy], ["Original", "Noisy"],
show=True,
main_title="Loaded Images",
cols=2,
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def harris_detector_bsize(image, bsizes, ksize, k, threshold, filter_params,
save, dpi, num):
image = util.load_image_RGB(image)
bsizes = json.loads(bsizes)
bsizes = np.rint(bsizes).astype(int)
filter_params = json.loads(filter_params)
if len(filter_params) == 2:
print("Applying Gaussian Filter")
image = cv.GaussianBlur(src=image,
ksize=(filter_params[0], filter_params[1]),
sigmaX=0,
sigmaY=0)
gray_image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
harris_images_bsize = []
harris_images_titles = []
for bsize in bsizes:
harris_image = np.copy(image)
mask = cv.cornerHarris(src=gray_image,
blockSize=bsize,
ksize=ksize,
k=k)
harris_image[mask > threshold * mask.max()] = [255, 0, 0]
harris_images_bsize.append(harris_image)
harris_images_titles.append(f"block size = {bsize}")
harris_images = harris_images_bsize
harris_images.insert(0, image)
titles_images = harris_images_titles
titles_images.insert(0, "Orig Image")
# Convert from Float 64 to Unsigned Int 8
# Also needs to be converted from np.array to list
harris_images = list(np.uint8(np.abs(harris_images)))
# Plots the images.
fig = util.plotImages(
harris_images,
titles_images,
show=True,
main_title="Harris Corner Detectorn - cv.cornerHarris"
f"\nsobel aperture = {ksize}"
f"\nharris parameter = {k}",
cmap="gray",
cols=2,
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def canny_filter(image, minval, maxval, ksize, filter_params, save, dpi, num):
image = util.load_image_RGB(image)
filter_params = json.loads(filter_params)
if len(filter_params) == 2:
print("Applying Gaussian Filter")
image = cv.GaussianBlur(src=image,
ksize=(filter_params[0], filter_params[1]),
sigmaX=0,
sigmaY=0)
# Best bilateral_params = (6, 200, 20)
elif len(filter_params) == 3:
print("Applying Bilateral Filter")
image = cv.bilateralFilter(src=image,
d=filter_params[0],
sigmaColor=filter_params[1],
sigmaSpace=filter_params[2])
image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
minVal = np.uint8(np.round(np.max(image) * minval))
maxVal = np.uint8(np.round(np.max(image) * maxval))
# Aperture size should be odd between 3 and 7 in function
canny_image = cv.Canny(image=image,
threshold1=minVal,
threshold2=maxVal,
apertureSize=ksize)
canny_images = [image, canny_image]
titles_images = [
"Orig Image", f"Canny\nminVal = {minVal}, maxVal = {maxVal}"
]
# Plots the images.
fig = util.plotImages(canny_images,
titles_images,
show=True,
main_title="Canny Filter - cv.Canny",
cmap="gray",
cols=2,
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def roberts_filter(image, filter_params, save, dpi, num):
image = util.load_image_RGB(image)
filter_params = json.loads(filter_params)
if len(filter_params) == 2:
print("Applying Gaussian Filter")
image = cv.GaussianBlur(src=image,
ksize=(filter_params[0], filter_params[1]),
sigmaX=0,
sigmaY=0)
# Best bilateral_params = (6, 200, 20)
elif len(filter_params) == 3:
print("Applying Bilateral Filter")
image = cv.bilateralFilter(src=image,
d=filter_params[0],
sigmaColor=filter_params[1],
sigmaSpace=filter_params[2])
image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
kernel_x = np.array([[1, 0], [0, -1]])
kernel_y = np.array([[0, 1], [-1, 0]])
roberts_x = cv.filter2D(src=image, ddepth=cv.CV_64F, kernel=kernel_x)
roberts_y = cv.filter2D(src=image, ddepth=cv.CV_64F, kernel=kernel_y)
roberts_xy = cv.magnitude(roberts_x, roberts_y)
# Before plotting we need to type convert
roberts_x = list(np.uint8(np.abs(roberts_x)))
roberts_y = list(np.uint8(np.abs(roberts_y)))
roberts_xy = list(np.uint8(np.abs(roberts_xy)))
roberts_images = [image, roberts_x, roberts_y, roberts_xy]
titles_images = ["Orig Image", "Roberts xx", "Roberts yy", "Magnitude"]
# Plots the images.
fig = util.plotImages(roberts_images,
titles_images,
show=True,
main_title="Roberts Filter - cv.filter2D",
cmap="gray",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def canny_filter_animate(image, minvals, maxvals, ksize, filter_params, save):
image = util.load_image_RGB(image)
minvals = json.loads(minvals)
maxvals = json.loads(maxvals)
filter_params = json.loads(filter_params)
if len(filter_params) == 2:
print("Applying Gaussian Filter")
image = cv.GaussianBlur(src=image,
ksize=(filter_params[0], filter_params[1]),
sigmaX=0,
sigmaY=0)
# Best bilateral_params = (6, 200, 20)
elif len(filter_params) == 3:
print("Applying Bilateral Filter")
image = cv.bilateralFilter(src=image,
d=filter_params[0],
sigmaColor=filter_params[1],
sigmaSpace=filter_params[2])
image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
# Aperture size should be odd between 3 and 7 in function
canny_images = []
canny_titles = []
minvals = np.rint(np.max(image) * np.array(minvals)).astype(int)
maxvals = np.rint(np.max(image) * np.array(maxvals)).astype(int)
for thrsh1 in minvals:
for thrsh2 in maxvals:
canny_images.append(
cv.Canny(image=image,
threshold1=thrsh1,
threshold2=thrsh2,
apertureSize=ksize))
canny_titles.append(f"minVal = {np.round(thrsh1)}, "
f"maxVal = {np.round(thrsh2)}")
# Do not repeat values cause thrsh1 = 200 and thrsh2 = 180 is the same
# as thrsh1 = 180 and thrsh2 = 200
maxvals = np.delete(maxvals, np.argwhere(maxvals == thrsh1))
util.animateImages(images=canny_images,
titles=canny_titles,
save_name=save,
cmap="gray",
frame_interval=120,
verbose=True)
def scharr_filter(image, filter_params, save, dpi, num):
image = util.load_image_RGB(image)
filter_params = json.loads(filter_params)
if len(filter_params) == 2:
print("Applying Gaussian Filter")
image = cv.GaussianBlur(src=image,
ksize=(filter_params[0], filter_params[1]),
sigmaX=0,
sigmaY=0)
# Best bilateral_params = (6, 200, 20)
elif len(filter_params) == 3:
print("Applying Bilateral Filter")
image = cv.bilateralFilter(src=image,
d=filter_params[0],
sigmaColor=filter_params[1],
sigmaSpace=filter_params[2])
image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
scharr_x = cv.Scharr(src=image, ddepth=cv.CV_64F, dx=1, dy=0)
scharr_y = cv.Scharr(src=image, ddepth=cv.CV_64F, dx=0, dy=1)
scharr_xy = cv.magnitude(scharr_x, scharr_y)
scharr_x = list(np.uint8(np.abs(scharr_x)))
scharr_y = list(np.uint8(np.abs(scharr_y)))
scharr_xy = list(np.uint8(np.abs(scharr_xy)))
scharr_images = [image, scharr_x, scharr_y, scharr_xy]
titles_images = [
"Original Image", "Scharr dx=1", "Scharr dy=1", "Magnitude"
]
# Plots the images.
fig = util.plotImages(scharr_images,
titles_images,
show=True,
main_title="Scharr Filter - cv.Scharr",
cmap="gray",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def mean_filter_anchor(image, kernel, crop_corner, crop_size, save, dpi, num):
image = util.load_image_RGB(image)
crop_corner = json.loads(crop_corner)
# Initialize the anchor_images as list. Values are assigned on the for-loop
# Initializes the kernel_max which is the maximum kernel value from Mean
# Filter section above.
anchor_images = []
titles_images = []
for a in range(0, kernel, round((kernel - 1) / 2) - 1):
anchor_images.append(cv.blur(image, (kernel, kernel), anchor=(a, a)))
titles_images.append(f"Anchor at ({a}, {a})")
# Crop blurred images to better see the effect of anchor.
anchor_images_crop = []
for i in range(len(anchor_images)):
anchor_images_crop.append(
anchor_images[i][crop_corner[1]:crop_corner[1] + crop_size,
crop_corner[0]:crop_corner[0] + crop_size])
# Saves individual the images.
# util.saveImages(anchor_images_crop, titles_images, dpi=300,
# save_name=save)
# Saves an animation.
util.animateImages(images=anchor_images_crop,
titles=titles_images,
save_name=save,
frame_interval=120,
verbose=True)
# Plots the images.
fig = util.plotImages(anchor_images_crop,
titles_images,
show=True,
main_title=f"Mean Filter Anchor @ Kernel "
f"{kernel}x{kernel} - cv.blur",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def harris_detector(image, bsize, ksize, k, threshold, filter_params, save,
dpi, num):
image = util.load_image_RGB(image)
filter_params = json.loads(filter_params)
if len(filter_params) == 2:
print("Applying Gaussian Filter")
image = cv.GaussianBlur(src=image,
ksize=(filter_params[0], filter_params[1]),
sigmaX=0,
sigmaY=0)
gray_image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
harris_image = np.copy(image)
mask = cv.cornerHarris(src=gray_image,
blockSize=bsize,
ksize=ksize,
k=k)
harris_image[mask > threshold * np.max(mask)] = [255, 0, 0]
# Convert from Float 64 to Unsigned Int 8
# Also needs to be converted from np.array to list
harris_image = list(np.uint8(np.abs(harris_image)))
# Plots the images.
fig = util.plotImages([image, harris_image],
["Orig Image", "Harris Output"],
show=True,
main_title="Harris Corner Detector - cv.cornerHarris"
f"\nblock size = {bsize}"
f"\nsobel aperture = {ksize}"
f"\nharris param = {k}",
cols=2,
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def laplacian_filter(image, ksize, filter_params, save, dpi, num):
image = util.load_image_RGB(image)
filter_params = json.loads(filter_params)
if len(filter_params) == 2:
print("Applying Gaussian Filter")
image = cv.GaussianBlur(src=image,
ksize=(filter_params[0], filter_params[1]),
sigmaX=0,
sigmaY=0)
# Best bilateral_params = (6, 200, 20)
elif len(filter_params) == 3:
print("Applying Bilateral Filter")
image = cv.bilateralFilter(src=image,
d=filter_params[0],
sigmaColor=filter_params[1],
sigmaSpace=filter_params[2])
image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
laplacian_image = cv.Laplacian(src=image, ddepth=cv.CV_64F, ksize=ksize)
laplacian_image = np.uint8(np.abs(laplacian_image))
laplacian_images = [image, laplacian_image]
titles_images = ["Orig Image", "Laplacian"]
# Plots the images.
fig = util.plotImages(laplacian_images,
titles_images,
show=True,
main_title="Laplacian Filter - cv.Laplacian",
cmap="gray",
cols=2,
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def harris_detector_animate(image, bsizes, ksizes, ks, threshold, save):
image = util.load_image_RGB(image)
gray_image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
bsizes = json.loads(bsizes)
ksizes = json.loads(ksizes)
ks = json.loads(ks)
bsizes = np.rint(bsizes).astype(int)
ksizes = np.rint(ksizes).astype(int)
ks = np.round(ks, 2)
harris_images = []
harris_titles = []
for bsize in bsizes:
for ksize in ksizes:
for k in ks:
# When the number its even add one to ensure ksize is odd
ksize = ksize + 1 if ksize % 2 == 0 else ksize
harris_image = np.copy(image)
mask = cv.cornerHarris(src=gray_image,
blockSize=bsize,
ksize=ksize,
k=k)
harris_image[mask > threshold * mask.max()] = [255, 0, 0]
harris_images.append(harris_image)
harris_titles.append(f"bsize={bsize}, ksize={ksize}, k={k}")
# Convert from Float 64 to Unsigned Int 8
# Also needs to be converted from np.array to list
harris_images = list(np.uint8(np.abs(harris_images)))
util.animateImages(images=harris_images,
titles=harris_titles,
save_name=save,
cmap="gray",
frame_interval=120,
verbose=True)
def bilateral_filter(image, diameters, sigma_c, sigma_s, save, dpi, num):
image = util.load_image_RGB(image)
diameters = json.loads(diameters)
# Initialize the bilateral_images as list.
# Values are assigned on the for-loop
bilateral_images = []
titles_images = []
for d in diameters:
bilateral_images.append(
cv.bilateralFilter(src=image,
d=d,
sigmaColor=sigma_c,
sigmaSpace=sigma_s))
titles_images.append(f"D = {d}")
# Copy the arrays with the images generated in the for-loop and adds the
# original noisy image for comparison. Also copies and adds the titles.
plot_images = bilateral_images
plot_images.insert(0, image)
plot_titles = titles_images
plot_titles.insert(0, "Noisy Image")
# Plots the images.
fig = util.plotImages(plot_images,
plot_titles,
show=True,
main_title=f"Bilateral Filter @ sigmaC = {sigma_c}, "
f"sigmaS = {sigma_s} - cv.bilateralFilter",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def my_harris(image, bsize, ksize, k, threshold, save, dpi, num):
assert type(bsize) is int, "blockSize must be type int"
assert type(ksize) is int, "ksize must be type int"
assert type(k) is float, "k must be type float"
assert bsize > 0, "blockSize must be greater than 0"
assert ksize == 1 or ksize == 3 or ksize == 5 or ksize == 7, \
"ksize must be type 1, 3, 5, or 7."
# 1st Step: Load the image and convert the image to Gray Scale
image = util.load_image_RGB(image)
gray_image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
# 2nd Step: Spatial derivative calculation
Ix = cv.Sobel(src=gray_image, ddepth=cv.CV_64F, dx=1, dy=0, ksize=ksize)
Iy = cv.Sobel(src=gray_image, ddepth=cv.CV_64F, dx=0, dy=1, ksize=ksize)
# 3rd Step: Get M Matrix fields
IxIx = Ix**2
IyIy = Iy**2
IxIy = Ix * Iy
# 4th Step: Calculate the determinant and the trace of the M Matrix
# Get the shape of the image
height, width = np.shape(gray_image)[:2]
# Initialize the array
R = np.empty((height, width))
# If the determinant is determined on a specific point do the calculus as
# it is described.
if bsize == 1:
# https://www.vcalc.com/equation/?uuid=ff927310-2410-11e6-9770-bc764e2038f2
detM = IxIx * IyIy - IxIy**2
# https://www.vcalc.com/wiki/SavannahBergen/Trace+of+a+2x2+Matrix
traceM = IxIx + IyIy
# 5th Step: Compute R Value
R = detM - k * (traceM**2)
# If the determinant is determined based on the sum of the window do the
# calculus with the sum of the M matrix components in that window
else:
offset = int(bsize / 2)
for row in range(offset, height - offset):
for col in range(offset, width - offset):
# 3rd Step: Get M matrix fields of the window defined
# by the blockSize parameter and Sum them.
Sum_IxIx = np.sum(IxIx[row - offset:row + offset + 1,
col - offset:col + offset + 1])
Sum_IyIy = np.sum(IyIy[row - offset:row + offset + 1,
col - offset:col + offset + 1])
Sum_IxIy = np.sum(IxIy[row - offset:row + offset + 1,
col - offset:col + offset + 1])
# 4th Step: Compute det and trace of M matrix
detM = Sum_IxIx * Sum_IyIy - Sum_IxIy**2
traceM = Sum_IxIx + Sum_IyIy
# 5th Step: Compute R Value of the pixel at (row, col)
R[row, col] = detM - k * (traceM**2)
# 6th Step: Decide if it's flat, edge or corner according to R value
threshold = threshold * np.max(R)
flats_image = np.copy(image)
flats_image[(R > -threshold) & (R < threshold)] = [255, 0, 0]
edges_image = np.copy(image)
edges_image[R <= -threshold] = [255, 0, 0]
corners_image = np.copy(image)
corners_image[R >= threshold] = [255, 0, 0]
# Beautiful Plot
fig = util.plotImages([image, flats_image, edges_image, corners_image],
["Orig Image", "Flat", "Edges", "Corners"],
main_title="My Harris",
show=True,
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def sobel_filter_ddepth(image, ksize, threshold, filter_params, save, dpi,
num):
image = util.load_image_RGB(image)
filter_params = json.loads(filter_params)
if len(filter_params) == 2:
print("Applying Gaussian Filter")
image = cv.GaussianBlur(src=image,
ksize=(filter_params[0], filter_params[1]),
sigmaX=0,
sigmaY=0)
# Best bilateral_params = (6, 200, 20)
elif len(filter_params) == 3:
print("Applying Bilateral Filter")
image = cv.bilateralFilter(src=image,
d=filter_params[0],
sigmaColor=filter_params[1],
sigmaSpace=filter_params[2])
image_gray = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
sobel_1st_float64 = cv.Sobel(src=image_gray,
ddepth=cv.CV_64F,
dx=1,
dy=0,
ksize=ksize)
sobel_1st_float64 = np.uint8(np.abs(sobel_1st_float64))
sobel_1st_uint8 = cv.Sobel(src=image_gray,
ddepth=cv.CV_8U,
dx=1,
dy=0,
ksize=ksize)
sobel_2nd_float64 = cv.Sobel(src=image_gray,
ddepth=cv.CV_64F,
dx=2,
dy=0,
ksize=ksize)
sobel_2nd_float64 = np.uint8(np.abs(sobel_2nd_float64))
sobel_2nd_uint8 = cv.Sobel(src=image_gray,
ddepth=cv.CV_8U,
dx=2,
dy=0,
ksize=ksize)
plot_images = [
sobel_1st_float64, sobel_1st_uint8, sobel_2nd_float64, sobel_2nd_uint8
]
plot_titles = ["dx=1 64F", "dx=1 8U", "dx=2 64F", "dx=2 8U"]
# Plots the Black and White images.
fig = util.plotImages(plot_images,
plot_titles,
show=True,
main_title="Sobel Derivatives Problems 1 - cv.Sobel",
cmap="gray",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save + "_1")
image_1st_uint8 = np.copy(image)
image_1st_float64 = np.copy(image)
image_2nd_uint8 = np.copy(image)
image_2nd_float64 = np.copy(image)
image_1st_uint8[sobel_1st_uint8 > threshold * np.max(sobel_1st_uint8)] \
= [255, 0, 0]
image_1st_float64[sobel_1st_float64 > threshold * np.max(sobel_1st_float64)] \
= [255, 0, 0]
image_2nd_uint8[sobel_2nd_uint8 > threshold * np.max(sobel_2nd_uint8)] \
= [255, 0, 0]
image_2nd_float64[sobel_2nd_float64 > threshold * np.max(sobel_2nd_float64)] \
= [255, 0, 0]
plot_images = [
image_1st_float64, image_1st_uint8, image_2nd_float64, image_2nd_uint8
]
plot_titles = ["dx=1 64F", "dx=1 8U", "dx=2 64F", "dx=2 8U"]
if num is not None:
num += 1
# Plots the images.
fig = util.plotImages(plot_images,
plot_titles,
show=True,
main_title="Sobel Derivatives Problems 2 - cv.Sobel",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save + "_2")
# Wait for a key press to close figures
input("Press Enter to continue...")
def sobel_filter(image, deriv_x, deriv_y, ksize, threshold, filter_params,
save, dpi, num):
image = util.load_image_RGB(image)
deriv_x = json.loads(deriv_x)
deriv_y = json.loads(deriv_y)
filter_params = json.loads(filter_params)
if len(filter_params) == 2:
print("Applying Gaussian Filter")
image = cv.GaussianBlur(src=image,
ksize=(filter_params[0], filter_params[1]),
sigmaX=0,
sigmaY=0)
# Best bilateral_params = (6, 200, 20)
elif len(filter_params) == 3:
print("Applying Bilateral Filter")
image = cv.bilateralFilter(src=image,
d=filter_params[0],
sigmaColor=filter_params[1],
sigmaSpace=filter_params[2])
image = cv.cvtColor(src=image, code=cv.COLOR_RGB2GRAY)
# Initialize the mean_images as list. Values are assigned on the for-loop
sobel_images_dx = []
titles_images_dx = []
for dx in deriv_x:
# If not specified or set to None KSize is 3!
sobel_images_dx.append(
cv.Sobel(src=image, ddepth=cv.CV_64F, dx=dx, dy=0, ksize=ksize))
titles_images_dx.append(f"dx = {dx}")
sobel_images_dy = []
titles_images_dy = []
for dy in deriv_y:
sobel_images_dy.append(
cv.Sobel(src=image, ddepth=cv.CV_64F, dx=0, dy=dy, ksize=ksize))
titles_images_dy.append(f"dy = {dy}")
mag = cv.magnitude(sobel_images_dx[-1], sobel_images_dy[-1])
ang = cv.phase(sobel_images_dx[-1],
sobel_images_dy[-1],
angleInDegrees=True)
# Values below threshold are set to zero.
# Needed to visualize the orientation/angle
_, mask = cv.threshold(mag, np.max(mag) * threshold, 1, cv.THRESH_BINARY)
mag = np.multiply(mask, mag)
ang = np.multiply(mask, ang)
sobel_images_dxdy = [mag, ang]
titles_images_dxdy = [
f"Magnitude\ndx = {max(deriv_x)}, "
f"dy = {max(deriv_y)}", f"Orientation\ndx = {max(deriv_x)}, "
f"dy = {max(deriv_y)}"
]
# Before plotting we need to type convert
sobel_images_dx = list(np.uint8(np.abs(sobel_images_dx)))
sobel_images_dy = list(np.uint8(np.abs(sobel_images_dy)))
sobel_images_dxdy = list(np.uint8(np.abs(sobel_images_dxdy)))
# Copy the arrays with the images generated in the for-loop and adds the
# original noisy image for comparison. Also copies and adds the titles.
plot_images = sobel_images_dx + sobel_images_dy + [sobel_images_dxdy[0]]
plot_images.insert(0, image)
plot_titles = titles_images_dx + titles_images_dy + [titles_images_dxdy[0]]
plot_titles.insert(0, "Original Image")
# Plots the images.
fig = util.plotImages(plot_images,
plot_titles,
show=True,
main_title="Sobel Filter - cv.Sobel",
cmap="gray",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
if num is not None:
num += 1
# Plots the images.
fig = util.plotImages(sobel_images_dxdy,
titles_images_dxdy,
show=True,
main_title="Sobel Filter - cv.Sobel",
cols=2,
cmap="turbo",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save + "_MagAng")
# Wait for a key press to close figures
input("Press Enter to continue...")
def gaussian_filter_sigma(image, sigma_x, sigma_y, crop_corner, crop_size,
save, dpi, num):
image = util.load_image_RGB(image)
sigma_x = json.loads(sigma_x)
sigma_y = json.loads(sigma_y)
crop_corner = json.loads(crop_corner)
# Initialize the gaussian_images_sigma as list.
# Values are assigned on the for-loop.
gaussian_images_sigmaX = []
titles_images_X = []
for sigX in sigma_x:
gaussian_images_sigmaX.append(
cv.GaussianBlur(image, (9, 9), sigmaX=sigX, sigmaY=0.1))
titles_images_X.append(f"SigmaX = {sigX}")
gaussian_images_sigmaY = []
titles_images_Y = []
for sigY in sigma_y:
# SigmaX and SigmaY is 0 so they are calculated from kernel
gaussian_images_sigmaY.append(
cv.GaussianBlur(image, (9, 9), sigmaX=0.1, sigmaY=sigY))
titles_images_Y.append(f"SigmaY = {sigY}")
# Crop filtered images to better see the effect of Sigma.
gaussian_images_sigmaX_crop = []
for i in range(len(gaussian_images_sigmaX)):
gaussian_images_sigmaX_crop.append(
gaussian_images_sigmaX[i][crop_corner[1]:crop_corner[1] +
crop_size,
crop_corner[0]:crop_corner[0] +
crop_size])
gaussian_images_sigmaY_crop = []
for i in range(len(gaussian_images_sigmaY)):
gaussian_images_sigmaY_crop.append(
gaussian_images_sigmaY[i][crop_corner[1]:crop_corner[1] +
crop_size,
crop_corner[0]:crop_corner[0] +
crop_size])
# Concat the arrays of sigmaX and sigmaY to plot
plot_images = gaussian_images_sigmaX_crop + gaussian_images_sigmaY_crop
# Concat the titles arrays of sigmaX and sigmaY to plot
plot_titles = titles_images_X + titles_images_Y
# Plots the images.
fig = util.plotImages(plot_images,
plot_titles,
show=True,
main_title="Gaussian Filter Sigmas @ Kernel 9x9 - "
"cv.GaussianBlur",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
def bilateral_filter_sigma(image, diameter, sigma_c, sigma_s, crop_corner,
crop_size, save, dpi, num):
image = util.load_image_RGB(image)
sigma_c = json.loads(sigma_c)
sigma_s = json.loads(sigma_s)
crop_corner = json.loads(crop_corner)
# Initialize the bilateral_images as list.
# Values are assigned on the for-loop
bilateral_images_sigmaC = []
titles_images_sigmaC = []
_sigS = min(sigma_s)
for sigC in sigma_c:
bilateral_images_sigmaC.append(
cv.bilateralFilter(src=image,
d=diameter,
sigmaColor=sigC,
sigmaSpace=_sigS))
titles_images_sigmaC.append(f"SigmaC = {sigC}")
bilateral_images_sigmaS = []
titles_images_sigmaS = []
_sigC = max(sigma_c)
for sigS in sigma_s:
bilateral_images_sigmaS.append(
cv.bilateralFilter(src=image,
d=diameter,
sigmaColor=_sigC,
sigmaSpace=sigS))
titles_images_sigmaS.append(f"SigmaS = {sigS}")
# Crop filtered images to better see the effect of Sigma.
bilateral_images_sigmaC_crop = []
for i in range(len(bilateral_images_sigmaC)):
bilateral_images_sigmaC_crop.append(
bilateral_images_sigmaC[i][crop_corner[1]:crop_corner[1] +
crop_size,
crop_corner[0]:crop_corner[0] +
crop_size])
bilateral_images_sigmaS_crop = []
for i in range(len(bilateral_images_sigmaC)):
bilateral_images_sigmaS_crop.append(
bilateral_images_sigmaS[i][crop_corner[1]:crop_corner[1] +
crop_size,
crop_corner[0]:crop_corner[0] +
crop_size])
plot_images = bilateral_images_sigmaC_crop + bilateral_images_sigmaS_crop
plot_titles = titles_images_sigmaC + titles_images_sigmaS
# Plots the images.
fig = util.plotImages(plot_images,
plot_titles,
show=True,
main_title=f"Bilateral Filter Sigma @"
f"D = {diameter} - cv.bilateralFilter",
num=num,
dpi=dpi)
# Saves the figure.
if save != "None":
fig.savefig(save)
# Wait for a key press to close figures
input("Press Enter to continue...")
