def alphaTrimmedMeanFilter(image, padding_type, kernel_size, trim_factor):
# TODO: Add check that trim factor is an integer (between 0 and (filtersize^2 - 1) /2)
log.debug("Applying alpha trimmed mean filter")
log.info("Selected padding type is - {}".format(padding_type))
log.info("Chosen kernel size is - {}".format(kernel_size))
padded_image = cv.copyMakeBorder(image, kernel_size // 2, kernel_size // 2,
kernel_size // 2, kernel_size // 2,
padding_type)
log.debug("Scanning the image and sorting each neighborhood")
width, height = image.shape
post_filter_image = np.zeros((width, height))
for row in range(width):
for col in range(height):
neighborhood = extractNeighborhood(matrix=padded_image,
row=row + kernel_size // 2,
col=col + kernel_size // 2,
neighborhood_size=kernel_size)
sorted_neighborhood = neighborhood.flatten()
sorted_neighborhood = np.sort(sorted_neighborhood)
post_filter_image[row][col] = np.sum(sorted_neighborhood[trim_factor:-trim_factor]) \
/ (len(sorted_neighborhood) - 2 * trim_factor)
log.debug("Finished scanning the image and sorting each neighborhood")
log.debug("Finished applying alpha trimmed mean filter")
return post_filter_image
def geometricMeanFilter(image, padding_type, kernel_size):
log.debug("Applying geometric mean filter")
log.info("Selected padding type is - {}".format(padding_type))
log.info("Chosen kernel size is - {}".format(kernel_size))
padded_image = cv.copyMakeBorder(image, kernel_size // 2, kernel_size // 2,
kernel_size // 2, kernel_size // 2,
padding_type)
padded_normalized_image = cv.normalize(padded_image, None, 1, 0,
cv.NORM_MINMAX, cv.CV_32F)
log.debug(
"Scanning the image and calculating the geometric mean for each neighborhood"
)
width, height = image.shape
post_filter_image = np.zeros((width, height))
geometric_constant = np.power(float(kernel_size), -2)
for row in range(width):
for col in range(height):
neighborhood = extractNeighborhood(matrix=padded_normalized_image,
row=row + kernel_size // 2,
col=col + kernel_size // 2,
neighborhood_size=kernel_size)
product = np.prod(neighborhood)
post_filter_image[row][col] = np.power(product, geometric_constant)
log.debug(
"Finished scanning the image and calculating the geometric mean for each neighborhood"
)
return_image = cv.normalize(post_filter_image, None, 255, 0,
cv.NORM_MINMAX, cv.CV_8UC1)
log.debug("Finished applying geometric mean filter")
return return_image
def minmaxFilter(image, padding_type, kernel_size, min_or_max):
log.debug("Applying min/max filter")
log.info("Selected padding type is - {}".format(padding_type))
log.info("Chosen kernel size is - {}".format(kernel_size))
options = {"min": np.min, "max": np.max}
padded_image = cv.copyMakeBorder(image, kernel_size // 2, kernel_size // 2,
kernel_size // 2, kernel_size // 2,
padding_type)
log.debug("Scanning the image and sorting each neighborhood")
log.info("Selected option (min/max) is - {}".format(min_or_max))
width, height = image.shape
post_filter_image = np.zeros((width, height))
for row in range(width):
for col in range(height):
neighborhood = extractNeighborhood(matrix=padded_image,
row=row + kernel_size // 2,
col=col + kernel_size // 2,
neighborhood_size=kernel_size)
post_filter_image[row][col] = options[min_or_max](neighborhood)
log.debug("Finished scanning the image and sorting each neighborhood")
log.debug("Finished applying min/max filter")
return post_filter_image
def medianFilter(image, padding_type, kernel_size):
log.debug("Applying median filter")
log.info("Selected padding type is - {}".format(padding_type))
log.info("Chosen kernel size is - {}".format(kernel_size))
padded_image = cv.copyMakeBorder(image, kernel_size // 2, kernel_size // 2,
kernel_size // 2, kernel_size // 2,
padding_type)
log.debug("Scanning the image and sorting each neighborhood")
width, height = image.shape
post_filter_image = np.zeros((width, height))
median_constant = np.power(kernel_size, 2) // 2
for row in range(width):
for col in range(height):
neighborhood = extractNeighborhood(matrix=padded_image,
row=row + kernel_size // 2,
col=col + kernel_size // 2,
neighborhood_size=kernel_size)
sorted_neighborhood = neighborhood.flatten()
sorted_neighborhood = np.sort(sorted_neighborhood)
post_filter_image[row][col] = sorted_neighborhood[median_constant]
log.debug("Finished scanning the image and sorting each neighborhood")
log.debug("Finished applying median filter")
return post_filter_image
def edgeDetectionMarrHildreth(image, padding_type1, padding_type2,
padding_type3, kernel_size, sigma,
threshold_value):
log.debug("Performing edge detection using Marr-Hildreth model (LoG)")
log.info("Chosen kernel size is - {}".format(kernel_size))
log.info("Selected deviation (to be used in the Gaussian filter) is - {}".
format(sigma))
# Step I - Smooth the image with a Gaussian low-pass kernel.
post_gaussian_filter = gaussianFilter(image=image,
border_type=padding_type1,
kernel_size=kernel_size,
sigma=sigma)
# Step II - Compute the Laplacian of the image resulting from step I.
post_laplacian_filter = laplacianGradientExtended(
image=post_gaussian_filter,
padding_type=padding_type2,
diagonal_terms=True,
contrast_stretch=False,
override=True)
post_filter_array = cv.copyMakeBorder(post_laplacian_filter, 1, 1, 1, 1,
padding_type3)
# Step III - Find the zero-crossing of the image from step II.
log.debug(
"Performing zero crossing for the post Gaussian-Laplacian filters")
log.info("Selected threshold is - {}".format(threshold_value))
width, height = image.shape
return_array = np.zeros((width, height))
for row in range(width):
for col in range(height):
neighborhood = extractNeighborhood(matrix=post_filter_array,
row=row + 1,
col=col + 1,
neighborhood_size=3)
return_array[row][col] = zeroCrossing(
neighborhood=neighborhood, threshold_value=threshold_value)
return_array = cv.convertScaleAbs(return_array)
log.debug("Finished performing edge detection using Marr-Hildreth model")
return return_array
def contraHarmonicMeanFilter(image, padding_type, kernel_size, order):
log.debug("Applying contra harmonic mean filter")
log.info("Selected padding type is - {}".format(padding_type))
log.info("Chosen kernel size is - {}".format(kernel_size))
padded_image = cv.copyMakeBorder(image, kernel_size // 2, kernel_size // 2,
kernel_size // 2, kernel_size // 2,
padding_type)
padded_normalized_image = cv.normalize(padded_image, None, 1, 0,
cv.NORM_MINMAX, cv.CV_32F)
log.debug(
"Scanning the image and calculating the contra harmonic mean for each neighborhood"
)
log.info("Selected order is - {}".format(order))
width, height = image.shape
post_filter_image = np.zeros((width, height))
for row in range(width):
for col in range(height):
neighborhood = extractNeighborhood(matrix=padded_normalized_image,
row=row + kernel_size // 2,
col=col + kernel_size // 2,
neighborhood_size=kernel_size)
denominator = np.sum(np.power(neighborhood, order))
if denominator == 0 is True:
post_filter_image[row][col] = 1
continue
numerator = np.sum(np.power(neighborhood, order + 1))
post_filter_image[row][col] = numerator / denominator
log.debug(
"Finished scanning the image and calculating the geometric mean for each neighborhood"
)
return_image = cv.normalize(post_filter_image, None, 255, 0,
cv.NORM_MINMAX, cv.CV_8UC1)
log.debug("Finished applying contra harmonic mean filter")
return return_image
def midpointFilter(image, padding_type, kernel_size):
log.debug("Applying midpoint filter")
log.info("Selected padding type is - {}".format(padding_type))
log.info("Chosen kernel size is - {}".format(kernel_size))
padded_image = cv.copyMakeBorder(image, kernel_size // 2, kernel_size // 2,
kernel_size // 2, kernel_size // 2,
padding_type)
log.debug("Scanning the image and sorting each neighborhood")
width, height = image.shape
post_filter_image = np.zeros((width, height))
for row in range(width):
for col in range(height):
neighborhood = extractNeighborhood(matrix=padded_image,
row=row + kernel_size // 2,
col=col + kernel_size // 2,
neighborhood_size=kernel_size)
post_filter_image[row][col] = 0.5 * (np.min(neighborhood) +
np.max(neighborhood))
log.debug("Finished scanning the image and sorting each neighborhood")
log.debug("Finished applying midpoint filter")
return post_filter_image