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)
