def apply_laplacian(img): r, g, b = rgb.get_rgb_layers(img) r, r_sharpened = filter.apply_laplacian(r) g, g_sharpened = filter.apply_laplacian(g) b, b_sharpened = filter.apply_laplacian(b) return rgb.merge_rgb_layers(r, g, b), rgb.merge_rgb_layers( r_sharpened, g_sharpened, b_sharpened)
def apply_piecewise_linear(self, coordinates_x=[0, 255], coordinates_y=[255, 0]): image = filter.apply_piecewise_linear(self.current_image, coordinates_x, coordinates_y) self.update_memory_images(image) return self.current_image
def show_histogram(self): a = filter.histogram(self.current_image) f = plt.figure() _ = plt.hist(a, bins='auto') # arguments are passed to np.histogram plt.title("Histogram") self.update_memory_images(self.current_image) return util.fig2img(f)
def apply_fourier(self): ft = self.fourierManager.fft2(self.current_image) shift = self.fourierManager.fftshift(ft) self.fourier_image = shift self.current_complete_fourier = shift.copy() mag = abs(shift) mag = np.log(mag) mag = filter.normalize_image(mag) mag = mag.astype(np.uint8).copy() self.update_fourier_memory_images(mag) return self.fourier_image
def save(self, name): filter.save_image(name, self.current_image)
def apply_gaussian(self, filter_size, sigma): image = filter.apply_gaussian(self.current_image, filter_size, sigma) self.update_memory_images(image) return self.current_image
def saveImage(self, name, image): filter.save_image(name, image)
def test_harmonic_mean_for_int_array(): input = np.array([1, 2, 4]) obtained = filter.get_harmonic_mean(input) assert obtained == 1.714
def apply_gradient(img, filter_matrix): r, g, b = rgb.get_rgb_layers(img) r = filter.apply_gradient(r, filter_matrix) g = filter.apply_gradient(g, filter_matrix) b = filter.apply_gradient(b, filter_matrix) return rgb.merge_rgb_layers(r, g, b)
def gammaTransform(self, gamma): image = filter.apply_gamma_correction(self.current_image, gamma) self.update_memory_images(image) return self.current_image
def apply_negative(img): r, g, b = rgb.get_rgb_layers(img) r = filter.apply_negative(r) g = filter.apply_negative(g) b = filter.apply_negative(b) return rgb.merge_rgb_layers(r, g, b)
def apply_geometric_mean(self, filter_size=3): image = filter.apply_geometric_mean(self.current_image, filter_size) self.update_memory_images(image) return self.current_image
def apply_contra_harmonic_mean(self, filter_size, q): image = filter.apply_contra_harmonic_mean(self.current_image, filter_size, q) self.update_memory_images(image) return self.current_image
def apply_sobel(self): image = filter.apply_sobel(self.current_image) self.update_memory_images(image) return self.current_image
def apply_gradient(self, filter_matrix): image = filter.apply_gradient(self.current_image, filter_matrix) self.update_memory_images(image) return self.current_image
def apply_convolution(self, filter_matrix): image = filter.apply_convolution(self.current_image, filter_matrix) self.update_memory_images(image) return self.current_image
def apply_arithmetic_mean(img, filter_matrix): r, g, b = rgb.get_rgb_layers(img) r = filter.apply_arithmetic_mean(r, filter_matrix) g = filter.apply_arithmetic_mean(g, filter_matrix) b = filter.apply_arithmetic_mean(b, filter_matrix) return rgb.merge_rgb_layers(r, g, b)
def apply_sobel(img): r, g, b = rgb.get_rgb_layers(img) r = filter.apply_sobel(r) g = filter.apply_sobel(g) b = filter.apply_sobel(b) return rgb.merge_rgb_layers(r, g, b)
def negativeTransform(self): image = (filter.apply_negative(self.current_image)).astype(np.uint8) self.update_memory_images(image) return self.current_image
def apply_highboost(self, filter_size, c): image, mask = filter.apply_highboost(self.current_image, c, filter_size) self.update_memory_images(image) return self.current_image
def logarithmicTransform(self, c): image = filter.apply_logarithmic(self.current_image, c) self.update_memory_images(image) return self.current_image
def test_harmonic_mean_for_matrix(): input = np.array([[1, 2, 4], [7, 9, 6], [15, 10, 1]]) obtained = filter.get_harmonic_mean(input) assert obtained == 0.899
def apply_equalized_histogram(self): image = filter.apply_histogram_equalization(self.current_image) self.update_memory_images(image) return self.current_image
def apply_piecewise_linear(img, coordinates_x, coordinates_y): r, g, b = rgb.get_rgb_layers(img) r = filter.apply_piecewise_linear(r, coordinates_x, coordinates_y) g = filter.apply_piecewise_linear(g, coordinates_x, coordinates_y) b = filter.apply_piecewise_linear(b, coordinates_x, coordinates_y) return rgb.merge_rgb_layers(r, g, b)
def apply_median(self, filter_size): image = filter.apply_median(self.current_image, filter_size) self.update_memory_images(image) return self.current_image
def apply_laplacian(self): image, mask = filter.apply_laplacian(self.current_image) self.update_memory_images(image) return self.current_image
def test_harmonic_mean_for_int_list(): input = [1, 2, 4] obtained = filter.get_harmonic_mean(input) assert obtained == 1.714
def apply_convolution(img, filter_matrix): r, g, b = rgb.get_rgb_layers(img) r = filter.apply_convolution(r, filter_matrix) g = filter.apply_convolution(g, filter_matrix) b = filter.apply_convolution(b, filter_matrix) return rgb.merge_rgb_layers(r, g, b)
def test_harmonic_mean_for_float_array(): input = np.array([1.0, 2.0, 4.0]) obtained = filter.get_harmonic_mean(input) assert obtained == 1.714
def apply_median(img, filter_size): r, g, b = rgb.get_rgb_layers(img) r = filter.apply_median(r, filter_size) g = filter.apply_median(g, filter_size) b = filter.apply_median(b, filter_size) return rgb.merge_rgb_layers(r, g, b)