def process(self): start = time() intensity = int(self.intensity_spin.value() / 100 * 127) invert = self.invert_check.isChecked() equalize = self.equalize_check.isChecked() self.intensity_spin.setEnabled(not equalize) blue_mode = self.blue_combo.currentIndex() if invert: dx = (-self.dx).astype(np.float32) dy = (-self.dy).astype(np.float32) else: dx = (+self.dx).astype(np.float32) dy = (+self.dy).astype(np.float32) dx_abs = np.abs(dx) dy_abs = np.abs(dy) red = ((dx / np.max(dx_abs) * 127) + 127).astype(np.uint8) green = ((dy / np.max(dy_abs) * 127) + 127).astype(np.uint8) if blue_mode == 0: blue = np.zeros_like(red) elif blue_mode == 1: blue = np.full_like(red, 255) elif blue_mode == 2: blue = norm_mat(dx_abs + dy_abs) elif blue_mode == 3: blue = norm_mat(np.linalg.norm(cv.merge((red, green)), axis=2)) else: blue = None gradient = cv.merge([blue, green, red]) if equalize: gradient = equalize_img(gradient) elif intensity > 0: gradient = cv.LUT(gradient, create_lut(intensity, intensity)) self.viewer.update_processed(gradient) self.info_message.emit( self.tr(f"Luminance Gradient = {elapsed_time(start)}"))
def process(self): intensity = self.intensity_spin.value() invert = self.invert_check.isChecked() equalize = self.equalize_check.isChecked() blue_mode = self.blue_combo.currentIndex() dx, dy = cv.spatialGradient(cv.cvtColor(self.image, cv.COLOR_BGR2GRAY)) if invert: dx = -dx dy = -dy red = ((dx.astype(np.float32) / np.max(np.abs(dx)) * 127) + 127).astype(np.uint8) green = ((dy.astype(np.float32) / np.max(np.abs(dy)) * 127) + 127).astype(np.uint8) if blue_mode == 0: blue = np.zeros_like(red) elif blue_mode == 1: blue = np.full_like(red, 255) elif blue_mode == 2: blue = normalize_mat(np.linalg.norm(cv.merge((red, green)), axis=2)) else: blue = None gradient = cv.merge([blue, green, red]) if intensity > 0: gradient = cv.LUT(gradient, create_lut(intensity, intensity)) if equalize: gradient = equalize_image(gradient) self.grad_viewer.update_processed(gradient)
def process(self): intensity = self.levels_spin.value() invert = self.invert_check.isChecked() absolute = self.abs_check.isChecked() self.levels_spin.setEnabled(not absolute) self.invert_check.setEnabled(not absolute) gray = cv.cvtColor(self.image, cv.COLOR_BGR2GRAY) diff_x = cv.Scharr(gray, cv.CV_32F, 1, 0) diff_y = cv.Scharr(gray, cv.CV_32F, 0, 1) diff_z = cv.normalize(np.abs(diff_x + diff_y), None, 0, 255, cv.NORM_MINMAX) diff_z = cv.LUT(diff_z.astype(np.uint8), create_lut(0, 90)) grad_x = +diff_x if invert else -diff_x grad_y = +diff_y if invert else -diff_y grad_z = diff_z if not absolute: min_x, max_x, _, _ = cv.minMaxLoc(grad_x) lim_x = max(abs(min_x), abs(max_x)) grad_x = (grad_x / lim_x + 1) * 127 min_y, max_y, _, _ = cv.minMaxLoc(grad_y) lim_y = max(abs(min_y), abs(max_y)) grad_y = (grad_y / lim_y + 1) * 127 else: grad_x = cv.normalize(np.abs(grad_x), None, 0, 255, cv.NORM_MINMAX) grad_y = cv.normalize(np.abs(grad_y), None, 0, 255, cv.NORM_MINMAX) grad_x = grad_x.astype(np.uint8) grad_y = grad_y.astype(np.uint8) if intensity >= 0 and not absolute: max_intensity = self.levels_spin.maximum() low = 127 - (max_intensity - intensity) high = 127 + (max_intensity - intensity) lut_xy = create_lut(low, high) grad_x = cv.LUT(grad_x, lut_xy) grad_y = cv.LUT(grad_y, lut_xy) else: grad_x = cv.equalizeHist(grad_x) grad_y = cv.equalizeHist(grad_y) gradient = np.stack((grad_z, grad_x, grad_y), axis=2) self.grad_viewer.update_processed(gradient)
def process(self): start = time() grayscale = self.gray_check.isChecked() if grayscale: original = cv.cvtColor(self.image, cv.COLOR_BGR2GRAY) else: original = self.image radius = self.radius_spin.value() kernel = radius * 2 + 1 sigma = self.sigma_spin.value() choice = self.mode_combo.currentText() if choice == self.tr('Median'): self.sigma_spin.setEnabled(False) denoised = cv.medianBlur(original, kernel) elif choice == self.tr('Gaussian'): self.sigma_spin.setEnabled(False) denoised = cv.GaussianBlur(original, (kernel, kernel), 0) elif choice == self.tr('BoxBlur'): self.sigma_spin.setEnabled(False) denoised = cv.blur(original, (kernel, kernel)) elif choice == self.tr('Bilateral'): self.sigma_spin.setEnabled(True) denoised = cv.bilateralFilter(original, kernel, sigma, sigma) elif choice == self.tr('NonLocal'): if grayscale: denoised = cv.fastNlMeansDenoising(original, None, kernel) else: denoised = cv.fastNlMeansDenoisingColored( original, None, kernel, kernel) else: denoised = None if self.denoised_check.isChecked(): self.levels_spin.setEnabled(False) result = denoised else: self.levels_spin.setEnabled(True) noise = cv.absdiff(original, denoised) levels = self.levels_spin.value() if levels == 0: if grayscale: result = cv.equalizeHist(noise) else: result = equalize_img(noise) else: result = cv.LUT(noise, create_lut(0, 255 - levels)) if grayscale: result = cv.cvtColor(result, cv.COLOR_GRAY2BGR) self.viewer.update_processed(result) self.info_message.emit( self.tr('Noise estimation = {}'.format(elapsed_time(start))))
def process(self): start = time() kernel = 2 * self.radius_spin.value() + 1 contrast = int(self.contrast_spin.value() / 100 * 255) lut = create_lut(0, contrast) laplace = [] for channel in cv.split(self.image): deriv = np.fabs(cv.Laplacian(channel, cv.CV_64F, None, kernel)) deriv = cv.normalize(deriv, None, 0, 255, cv.NORM_MINMAX, cv.CV_8UC1) laplace.append(cv.LUT(deriv, lut)) self.viewer.update_processed(cv.merge(laplace)) self.info_message.emit('Echo Edge Filter = {}'.format( elapsed_time(start)))
def process(self): start = time() scale = self.scale_spin.value() contrast = int(self.contrast_spin.value() / 100 * 128) linear = self.linear_check.isChecked() grayscale = self.gray_check.isChecked() if not linear: difference = cv.absdiff(self.original, self.compressed.astype(np.float32) / 255) ela = cv.convertScaleAbs(cv.sqrt(difference) * 255, None, scale / 20) else: ela = cv.convertScaleAbs(cv.subtract(self.compressed, self.image), None, scale) ela = cv.LUT(ela, create_lut(contrast, contrast)) if grayscale: ela = desaturate(ela) self.viewer.update_processed(ela) self.info_message.emit(self.tr('Error Level Analysis = {}'.format(elapsed_time(start))))
def process(self): start = time() quality = self.quality_spin.value() scale = self.scale_spin.value() / 20 contrast = int(self.contrast_spin.value() / 100 * 128) equalize = self.equalize_check.isChecked() grayscale = self.gray_check.isChecked() self.scale_spin.setEnabled(not equalize) self.contrast_spin.setEnabled(not equalize) compressed = compress_jpeg(self.image, quality).astype(np.float32) / 255 difference = cv.absdiff(self.original, compressed) if equalize: ela = equalize_img((difference * 255).astype(np.uint8)) else: ela = cv.convertScaleAbs(cv.sqrt(difference) * 255, None, scale) ela = cv.LUT(ela, create_lut(contrast, contrast)) if grayscale: ela = desaturate(ela) self.viewer.update_processed(ela) self.info_message.emit(self.tr('Error Level Analysis = {}'.format(elapsed_time(start))))
def process(self): brightness = self.bright_slider.value() saturation = self.sat_slider.value() hue = self.hue_slider.value() gamma = self.gamma_slider.value() / 10 shadows = self.shadow_slider.value() highlights = self.high_slider.value() equalize = self.equalize_combo.currentIndex() invert = self.invert_check.isChecked() sweep = self.sweep_slider.value() width = self.width_slider.value() threshold = self.thr_slider.value() result = np.copy(self.image) if brightness != 0 or saturation != 0 or hue != 0: h, s, v = cv.split(cv.cvtColor(result, cv.COLOR_BGR2HSV)) if hue != 0: h = h.astype(np.float64) + hue h[h < 0] += 180 h[h > 180] -= 180 h = h.astype(np.uint8) if saturation != 0: s = cv.add(s, saturation) if brightness != 0: v = cv.add(v, brightness) result = cv.cvtColor(cv.merge([h, s, v]), cv.COLOR_HSV2BGR) if gamma != 0: inverse = 1 / gamma lut = np.array([((i / 255)**inverse) * 255 for i in np.arange(0, 256)]).astype(np.uint8) result = cv.LUT(result, lut) if shadows != 0: result = cv.LUT(result, create_lut(int(shadows / 100 * 255), 0)) if highlights != 0: result = cv.LUT(result, create_lut(0, int(highlights / 100 * 255))) if width < 255: radius = width // 2 low = max(sweep - radius, 0) high = 255 - min(sweep + radius, 255) result = cv.LUT(result, create_lut(low, high)) if equalize > 0: h, s, v = cv.split(cv.cvtColor(result, cv.COLOR_BGR2HSV)) if equalize == 1: v = cv.equalizeHist(v) elif equalize > 1: clip = 0 if equalize == 2: clip = 2 elif equalize == 3: clip = 10 elif equalize == 4: clip = 20 elif equalize == 5: clip = 40 v = cv.createCLAHE(clip).apply(v) result = cv.cvtColor(cv.merge([h, s, v]), cv.COLOR_HSV2BGR) if threshold < 255: if threshold == 0: gray = cv.cvtColor(result, cv.COLOR_BGR2GRAY) threshold, _ = cv.threshold(gray, 0, 255, cv.THRESH_OTSU) _, result = cv.threshold(result, threshold, 255, cv.THRESH_BINARY) if invert: result = cv.bitwise_not(result) self.viewer.update_processed(result)