def apply_gradient(img, filter_matrix):
'''
Apply gradient using a single filter_matrix (3x3).
'''
# filter_height, filter_width = util.get_dimensions(
# filter_matrix)
# assert filter_height != 3, "Filter Matrix must have height = 3 instead of " + \
# str(filter_height)
# assert filter_width != 3, "Filter Matrix must have width = 3 instead of " + \
# str(filter_width)
height, width = util.get_dimensions(img)
# define image with 0s
new_gradient_image = np.zeros((height, width), np.uint8)
if len(img.shape) == 2:
for i in range(1, height - 1):
for j in range(1, width - 1):
grad = ImageFilter.apply_gradient_core(
filter_matrix, img, i, j)
new_gradient_image[i - 1, j - 1] = abs(grad)
else:
R = ImageFilter.apply_gradient(img[:, :, 0], filter_matrix)
G = ImageFilter.apply_gradient(img[:, :, 1], filter_matrix)
B = ImageFilter.apply_gradient(img[:, :, 2], filter_matrix)
output = np.zeros((R.shape[0], R.shape[1], 3), dtype=np.uint8)
output[:, :, 0] = R
output[:, :, 1] = G
output[:, :, 2] = B
new_gradient_image = output
return new_gradient_image
def adjust_brightness(img, br):
"""
0 < br < 1: decrease brightness
br = 1: no changes
br >: increase brightness
"""
height, width = util.get_dimensions(img)
obtained = np.zeros((height, width, 3), np.uint8)
for i in range(height):
for j in range(width):
for k in range(img.shape[2]):
b = img[i][j][k] * br
if b > 255:
b = 255
obtained[i][j][k] = b
return obtained.astype(np.uint8)
def apply_sobel(img):
# Horizontal sobel matrix
horizontal = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
# Vertical sobel matrix
vertical = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])
height, width = util.get_dimensions(img)
# define images with 0s
new_horizontal_image = np.zeros((height, width), np.uint8)
new_vertical_image = np.zeros((height, width), np.uint8)
new_gradient_image = np.zeros((height, width), np.uint8)
if len(img.shape) == 2:
# # define images with 0s
# new_horizontal_image = np.zeros((height, width), np.uint8)
# new_vertical_image = np.zeros((height, width), np.uint8)
# new_gradient_image = np.zeros((height, width), np.uint8)
for i in range(1, height - 1):
for j in range(1, width - 1):
horizontal_grad = ImageFilter.apply_gradient_core(
horizontal, img, i, j)
new_horizontal_image[i - 1, j - 1] = abs(horizontal_grad)
vertical_grad = ImageFilter.apply_gradient_core(
vertical, img, i, j)
new_vertical_image[i - 1, j - 1] = abs(vertical_grad)
# Edge Magnitude
new_gradient_image[i - 1, j - 1] = np.sqrt(
pow(horizontal_grad, 2.0) + pow(vertical_grad, 2.0))
else:
R = ImageFilter.apply_sobel(img[:, :, 0])
G = ImageFilter.apply_sobel(img[:, :, 1])
B = ImageFilter.apply_sobel(img[:, :, 2])
output = np.zeros((R.shape[0], R.shape[1], 3), dtype=np.uint8)
output[:, :, 0] = R
output[:, :, 1] = G
output[:, :, 2] = B
new_gradient_image = output
return new_gradient_image
def apply_piecewise_linear(img, coordinates_x, coordinates_y):
"""Apply Piecewise Linear filter on an image basead on an group of coordinates.
Parameters
----------
img : numpy array
The target image where the filter would be applied
coordinates_x : array
The coordinates X from all points to the interpolated already in the desired order.
coordinates_y : array
The coordinates Y from all points to the interpolated already in the desired order.
Returns
-------
numpy array
an array representing the obtained image after apply the filter
"""
x = np.array(range(0, _MAX_PIXEL + 1), dtype=np.uint8)
interp = np.interp(x, coordinates_x, coordinates_y)
obtained = img.copy()
height, width = util.get_dimensions(obtained)
if len(img.shape) == 2:
for i in range(height):
for j in range(width):
index = int(np.round(obtained[i][j]))
obtained[i][j] = interp[index]
else:
R = ImageFilter.apply_piecewise_linear(img[:, :, 0], coordinates_x,
coordinates_y)
G = ImageFilter.apply_piecewise_linear(img[:, :, 1], coordinates_x,
coordinates_y)
B = ImageFilter.apply_piecewise_linear(img[:, :, 2], coordinates_x,
coordinates_y)
output = np.zeros((R.shape[0], R.shape[1], 3), dtype=np.uint8)
output[:, :, 0] = R
output[:, :, 1] = G
output[:, :, 2] = B
obtained = output
return obtained
def adjust_intensity (img, factor):
'''
Adjust image hue using a mulplication factor.
Input: image and factor in [0.0, 1.0].
Output: image with intensity adjusted
'''
height,width = util.get_dimensions(img)
obtained = np.zeros_like(img)
for row in range(height):
for col in range(width):
r = img[row][col][0]
g = img[row][col][1]
b = img[row][col][2]
h,s,i = converter.rgb_to_hsi(r,g,b)
new_intensity = i * factor #Intensity value is [0, 1]
if new_intensity > 1:
new_intensity = 1
r,g,b = converter.hsi_to_rgb(h,s,new_intensity)
obtained[row][col][0] = r
obtained[row][col][1] = g
obtained[row][col][2] = b
return obtained
def adjust_hue (img, factor):
'''
Adjust image hue using a mulplication factor.
Input: image and factor in [0.0, 1.0].
Output: image with hue adjusted
'''
height,width = util.get_dimensions(img)
obtained = np.zeros_like(img)
for row in range(height):
for col in range(width):
r = img[row][col][0]
g = img[row][col][1]
b = img[row][col][2]
h,s,i = converter.rgb_to_hsi(r,g,b)
new_hue = h * factor #Hue value is [0, 360]
if new_hue > 360:
new_hue = 360
r,g,b = converter.hsi_to_rgb(new_hue,s,i)
obtained[row][col][0] = r
obtained[row][col][1] = g
obtained[row][col][2] = b
return obtained
def get_geometric_mean(matrix):
prod_value = np.prod(matrix)
height, width = util.get_dimensions(matrix)
counter = height * width
result = prod_value**(1.0 / counter)
return np.around(result, decimals=3)
def get_arithmetic_mean(neighbors):
sum_value = np.sum(neighbors)
height, width = util.get_dimensions(neighbors)
return sum_value / (height * width)
