def process(self, rect):
y1 = rect.top()
y2 = rect.bottom()
x1 = rect.left()
x2 = rect.right()
roi = self.image[y1:y2, x1:x2]
if self.equalize_radio.isChecked():
self.centile_spin.setEnabled(False)
self.channel_check.setEnabled(False)
roi = equalize_img(roi)
self.last_radio = self.equalize_radio
elif self.contrast_radio.isChecked():
self.centile_spin.setEnabled(True)
self.channel_check.setEnabled(True)
centile = self.centile_spin.value() / 200
if self.channel_check.isChecked():
roi = cv.merge(
[cv.LUT(c, auto_lut(c, centile)) for c in cv.split(roi)])
else:
roi = cv.LUT(
roi, auto_lut(cv.cvtColor(roi, cv.COLOR_BGR2GRAY),
centile))
self.last_radio = self.contrast_radio
else:
self.last_radio.setChecked(True)
return
processed = np.copy(self.image)
processed[y1:y2, x1:x2] = roi
self.viewer.update_processed(processed)
def change(self):
if self.normal_radio.isChecked():
result = self.reference
self.gray_check.setEnabled(False)
self.equalize_check.setEnabled(False)
self.last_radio = self.normal_radio
elif self.difference_radio.isChecked():
result = self.difference
self.gray_check.setEnabled(True)
self.equalize_check.setEnabled(True)
self.last_radio = self.difference_radio
elif self.ssim_radio.isChecked():
result = self.ssim_map
self.gray_check.setEnabled(False)
self.equalize_check.setEnabled(True)
self.last_radio = self.ssim_radio
elif self.butter_radio.isChecked():
result = self.butter_map
self.gray_check.setEnabled(True)
self.equalize_check.setEnabled(False)
self.last_radio = self.butter_radio
else:
self.last_radio.setChecked(True)
return
if self.equalize_check.isChecked():
result = equalize_img(result)
if self.gray_check.isChecked():
result = desaturate(result)
self.reference_viewer.update_original(result)
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):
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):
index = 3 * self.component_combo.currentIndex()
if self.distance_radio.isChecked():
output = self.output[index]
self.last_radio = self.distance_radio
elif self.project_radio.isChecked():
output = self.output[index + 1]
self.last_radio = self.project_radio
elif self.crossprod_radio.isChecked():
output = self.output[index + 2]
self.last_radio = self.crossprod_radio
else:
self.last_radio.setChecked(True)
return
if self.invert_check.isChecked():
output = cv.bitwise_not(output)
if self.equalize_check.isChecked():
output = equalize_img(output)
self.viewer.update_processed(output)
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))))
