class MainView(QMainWindow): def __init__(self, title, parent=None): super(MainView, self).__init__(parent) self.setWindowTitle(title) # 1. Create main_vbox and main_vlayout self.main_vbox = QWidget(self) self.main_vlayout = QVBoxLayout(self.main_vbox) self.main_vlayout.setAlignment(Qt.AlignTop) # 2, Create labeled_slider in main_vbox self.labeled_slider = ZLabeledSlider(self.main_vbox, take_odd=False, minimum=10, maximum=300, value=100, orientation=Qt.Horizontal, fixed_width=180) self.labeled_slider.add_value_changed_callback( self.slider_value_changed) self.labeled_slider.set_range(0, 200) self.labeled_slider.set_value(100) # 3. Add labeled_slider to main_vlayout. self.main_vlayout.addWidget(self.labeled_slider) self.labeled_slider.setGeometry(0, 0, 160, 70) self.setCentralWidget(self.main_vbox) self.show() # Callback for the slider in ZLabeledSlider. def slider_value_changed(self, value): self.labeled_slider.set_value_text(str(value)) print("MainView.slider_value_changed:{}".format(value)) def get_labeled_slider(self): return self.labeled_slider
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class DetectedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() def detect(self, hParameter, template_window_size, search_window_size): src_image = self.get_opencv_image() denoized_image = cv2.fastNlMeansDenoising(src_image, hParameter, template_window_size, search_window_size) self.set_opencv_image(denoized_image) self.update() #-------------------------------------------- # Class variables H_PARAMETER_MAX = 31 TEMPLATE_WINDOW_SIZE_MAX = 31 SEARCH_WINDOW_SIZE_MAX = 31 # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/MeshedNioh.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.detected_image_view = self.DetectedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add imageviews to the main_layout which is a horizontal layouter. self.add(self.source_image_view) self.add(self.detected_image_view) #self.detected_image_view.detect(self.hParameter, # self.template_window_size, self.search_window_size) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.hParameter = 21 self.hParameter_slider = ZLabeledSlider(self.vpane, "H Parameter", take_odd=False, minimum=1, maximum=self.H_PARAMETER_MAX, value=self.hParameter) self.hParameter_slider.add_value_changed_callback( self.hParameter_changed) self.template_window_size = 15 self.template_window_size_slider = ZLabeledSlider( self.vpane, "TemplateWindowSize", take_odd=False, minimum=1, maximum=self.TEMPLATE_WINDOW_SIZE_MAX, value=self.template_window_size) self.template_window_size_slider.add_value_changed_callback( self.template_window_size_changed) self.search_window_size = 13 self.search_window_size_slider = ZLabeledSlider( self.vpane, "SearchWindowSize", take_odd=False, minimum=1, maximum=self.SEARCH_WINDOW_SIZE_MAX, value=self.search_window_size) self.search_window_size_slider.add_value_changed_callback( self.search_window_size_changed) self.vpane.add(self.hParameter_slider) self.vpane.add(self.template_window_size_slider) self.vpane.add(self.search_window_size_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.detected_image_view.load(filename) self.detected_image_view.detect(self.hParameter, self.template_window_size, self.search_window_size) self.set_filenamed_title(filename) def hParameter_changed(self, value): self.hParameter = int(value) print("slider1_value_changed:{}".format(value)) self.detected_image_view.detect(self.hParameter, self.template_window_size, self.search_window_size) def template_window_size_changed(self, value): self.template_window = int(value) print("slider1_value_changed:{}".format(value)) self.detected_image_view.detect(self.hParameter, self.template_window_size, self.search_window_size) def search_window_size_changed(self, value): self.search_window_size = int(value) print("slider1_value_changed:{}".format(value)) self.detected_image_view.detect(self.hParameter, self.template_window_size, self.search_window_size)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class DetectedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): source_image = self.load_opencv_image(filename) self.gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) #The following detect_cornert method is based on the code: #http:#www.swarthmore.edu/NatSci/mzucker1/opencv-2.4.10-docs/ # doc/tutorials/features2d/trackingmotion/harris_detector/harris_detector.html def detect(self, bsize, ksize, threshold): source_image = self.get_opencv_image() #blockSize: Neighborhood size. #ksize : Aperture parameter for the Sobel operator, # which should be odd. ksize = int(ksize) #k: Harris detector free parameter. k = float(0.04) w, h, c = source_image.shape dest_image = np.zeros([w, h], dtype=np.uint8) gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) dest_image = cv2.cornerHarris(gray_image, bsize, ksize, k, cv2.BORDER_DEFAULT) cv2.normalize(dest_image, dest_image, 0, 255, cv2.NORM_MINMAX) #We draw circles at the corners detected by cornerHarris on the originalImage # by using the destNormalized image data and the threshold parameter # which is used to draw the circles.. detected_image = source_image.copy() iw, ih = dest_image.shape for j in range(iw): for i in range(ih): if dest_image[j, i] > threshold: cv2.circle(detected_image, (i, j), 5, (0, 0, 255), 1, 8, 0) self.set_opencv_image(detected_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/Geometry.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.detectd_image_view = self.DetectedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.detectd_image_view) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.blockSize = 7 self.kernelSize = 5 self.detectorThreshold = 100 self.blockSizeance_slider = ZLabeledSlider(self.vpane, "BlockSize", take_odd=False, minimum=2, maximum=100, value=self.blockSize, fixed_width=200) self.blockSizeance_slider.add_value_changed_callback( self.blockSizeance_value_changed) self.kernelSize_slider = ZLabeledSlider(self.vpane, "KernelSize", take_odd=True, minimum=3, maximum=31, value=self.kernelSize, fixed_width=200) self.kernelSize_slider.add_value_changed_callback( self.kernelSize_value_changed) self.detectorThreshold_slider = ZLabeledSlider( self.vpane, "DetectorThreshold", take_odd=False, minimum=100, maximum=240, value=self.detectorThreshold, fixed_width=200) self.detectorThreshold_slider.add_value_changed_callback( self.detectorThreshold_value_changed) self.vpane.add(self.blockSizeance_slider) self.vpane.add(self.kernelSize_slider) self.vpane.add(self.detectorThreshold_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.detectd_image_view.load(filename) self.detectd_image_view.detect(self.blockSize, self.kernelSize, self.detectorThreshold) self.set_filenamed_title(filename) def blockSizeance_value_changed(self, value): self.blockSize = int(value) self.detectd_image_view.detect(self.blockSize, self.kernelSize, self.detectorThreshold) def kernelSize_value_changed(self, value): self.kernelSize = int(value) self.detectd_image_view.detect(self.blockSize, self.kernelSize, self.detectorThreshold) def detectorThreshold_value_changed(self, value): self.detectorThreshold = int(value) self.detectd_image_view.detect(self.blockSize, self.kernelSize, self.detectorThreshold)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class NoisedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) self.noised_image = None def load(self, filename): self.load_opencv_image(filename) self.update() def inject_noise(self, sault, pepper): src_image = self.get_opencv_image() injector = ZSaultPepperNoiseInjector(sault/100.0) self.noised_image = injector.inject_to(src_image) self.set_opencv_image(self.noised_image) self.update() def get_noised_image(self): return self.noised_image #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) self.filename = "../images/SlantCatImage.png" self.filename = os.path.abspath(self.filename) # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.noised_image_view = self.NoisedImageView(self) # 3 Load the file self.load_file(self.filename) # 4 Add imageviews to the main_layout which is a horizontal layouter. self.add(self.source_image_view) self.add(self.noised_image_view) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.sault = 30 self.sault_slider = ZLabeledSlider(self.vpane, "Sault", take_odd =False, minimum=0, maximum=100, value=self.sault) self.sault_slider.add_value_changed_callback(self.sault_changed) self.pepper = 30 self.pepper_slider = ZLabeledSlider(self.vpane, "Pepper", take_odd =False, minimum=0, maximum=100, value=self.sault) self.pepper_slider.add_value_changed_callback(self.pepper_changed) self.vpane.add(self.sault_slider) self.vpane.add(self.pepper_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() self.filename, _ = QFileDialog.getOpenFileName(self,"FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if self.filename: self.load_file(self.filename) def file_save(self): options = QFileDialog.Options() dir, name = os.path.split(self.filename) filename = "Noised" + name save_filename, _ = QFileDialog.getSaveFileName(self,"FileSaveDialog-NoisedImage", filename, "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if save_filename: noised_image = self.noised_image_view.get_noised_image() cv2.imwrite(save_filename, noised_image) def load_file(self, filename): self.source_image_view.load(filename) self.noised_image_view.load(filename) self.noised_image_view.inject_noise(self.sault, self.pepper) self.set_filenamed_title(filename) def sault_changed(self, value): self.sault = int(value) #print("slider1_value_changed:{}".format(value)) self.noised_image_view.inject_noise(self.sault, self.pepper) def pepper_changed(self, value): self.pepper = int(value) #print("slider1_value_changed:{}".format(value)) self.noised_image_view.inject_noise(self.sault, self.pepper)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class DetectedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) self.gray_image = None def load(self, filename): self.load_opencv_image(filename) source_image = self.get_opencv_image() self.gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) def detect(self, ksize, sigma, threshold1, paramThreshold): ksize = int(ksize) source_image = self.get_opencv_image() #1 Apply cv::GaussianBlur to the source_image. blurred_image = cv2.GaussianBlur(self.gray_image, (ksize, ksize), sigma, sigma) #2 Apply cv::HoughCircles to the grayImage to detect circles. w, h = blurred_image.shape circles = cv2.HoughCircles(blurred_image, cv2.HOUGH_GRADIENT, 1, minDist=w / 8, param1=threshold1, param2=paramThreshold, minRadius=0, maxRadius=0) if circles is not None: detected_image = source_image.copy() for circle in circles[0, :]: #3 Draw the center of the circle of radius = 3 cv2.circle(detected_image, (circle[0], circle[1]), 3, (0, 255, 0), -1, 8, 0) #4 Draw the outline of the circle of radius cv2.circle(detected_image, (circle[0], circle[1]), circle[2], (0, 0, 255), 3, 8, 0) self.set_opencv_image(detected_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/Geometry3.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.detected_image_view = self.DetectedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.detected_image_view) self.show() # Add control pane to MainView def add_control_pane(self, fixed_width=200): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.ksize = 3 self.ksize_slider = ZLabeledSlider(self.vpane, "GaussianBlur KernelSize", take_odd=True, minimum=0, maximum=31, value=self.ksize) self.ksize_slider.add_value_changed_callback(self.ksize_value_changed) self.vpane.add(self.ksize_slider) self.sigma = 2 self.sigma_slider = ZLabeledSlider(self.vpane, "GaussianBlur SigmaSize", take_odd=True, minimum=1, maximum=21, value=self.sigma) self.sigma_slider.add_value_changed_callback(self.sigma_value_changed) self.vpane.add(self.sigma_slider) self.threshold1 = 120 self.threshold2 = 50 self.threshold1_slider = ZLabeledSlider(self.vpane, "CannyEdgeThreshold1", take_odd=True, minimum=0, maximum=300, value=self.threshold1) self.threshold1_slider.add_value_changed_callback( self.slider1_value_changed) self.vpane.add(self.threshold1_slider) self.threshold2_slider = ZLabeledSlider(self.vpane, "ParamThreshold", take_odd=True, minimum=0, maximum=300, value=self.threshold2) self.threshold2_slider.add_value_changed_callback( self.slider2_value_changed) self.vpane.add(self.threshold2_slider) self.set_right_dock(self.vpane) # Show FileOpenDialog and select an image file. def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.detected_image_view.load(filename) self.detected_image_view.detect(int(self.ksize), int(self.sigma), self.threshold1, self.threshold2) self.set_filenamed_title(filename) # Slider value changed callback. def ksize_value_changed(self, value): self.ksize = int(value) if self.ksize % 2 == 0: self.ksize = (self.ksize * 2) / 2 + 1 # Kernel size should be odd. #print("slider_value_changed:{}".format(ksize)) self.detected_image_view.detect(int(self.ksize), int(self.sigma), self.threshold1, self.threshold2) # Slider value changed callback. def sigma_value_changed(self, value): self.sigma = int(value) #print("slider_value_changed:{}".format(ksize)) self.detected_image_view.detect(int(self.ksize), int(self.sigma), self.threshold1, self.threshold2) def slider1_value_changed(self, value): self.threshold1 = int(value) self.detected_image_view.detect(int(self.ksize), int(self.sigma), self.threshold1, self.threshold2) def slider2_value_changed(self, value): self.threshold2 = int(value) self.detected_image_view.detect(int(self.ksize), int(self.sigma), self.threshold1, self.threshold2)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class DetectedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) self.gray_image = None def load(self, filename): self.load_opencv_image(filename) source_image = self.get_opencv_image() self.gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) def detect(self, threshold1, threshold2): if self.gray_image.all() != None: detected_image = cv2.Canny(self.gray_image, threshold1, threshold2) self.set_opencv_image(detected_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/Cloud.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.detected_image_view = self.DetectedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.detected_image_view) self.show() def add_control_pane(self, fixed_width=200): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.threshold1 = 50 self.threshold2 = 100 self.threshold1_slider = ZLabeledSlider(self.vpane, "Threshold1", take_odd=True, minimum=0, maximum=300, value=self.threshold1) self.threshold1_slider.add_value_changed_callback( self.slider1_value_changed) self.vpane.add(self.threshold1_slider) self.threshold2_slider = ZLabeledSlider(self.vpane, "Threshold2", take_odd=True, minimum=0, maximum=300, value=self.threshold2) self.threshold2_slider.add_value_changed_callback( self.slider2_value_changed) self.vpane.add(self.threshold2_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.detected_image_view.load(filename) # Apply detect method to the detected image view. self.detected_image_view.detect(self.threshold1, self.threshold2) self.set_filenamed_title(filename) def slider1_value_changed(self, value): self.threshold1 = int(value) self.detected_image_view.detect(int(self.threshold1), int(self.threshold2)) def slider2_value_changed(self, value): self.threshold2 = int(value) self.detected_image_view.detect(int(self.threshold1), int(self.threshold2))
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class FilteredImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.source_image = self.load_opencv_image(filename) def filter(self, sigmaColor, sigmaSpace): if self.source_image.all() != None: flag = cv2.RECURS_FILTER filtered_image = cv2.edgePreservingFilter( self.source_image, flag, sigma_s=sigmaSpace, sigma_r=float(sigmaColor) / 100.0) self.set_opencv_image(filtered_image) self.update() #-------------------------------------------- SIGMA_COLOR_MAX = 100 SIGMA_SPACE_MAX = 200 # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/flower.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.filtered_image_view = self.FilteredImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.filtered_image_view) self.show() def add_control_pane(self, fixed_width=200): self.vbox = QWidget(self) self.vbox.setMinimumWidth(fixed_width) self.vbox.setMaximumWidth(fixed_width) vlayout = QVBoxLayout(self.vbox) self.sigmaColor = 40 self.sigmaSpace = 160 self.sigmaColor_slider = ZLabeledSlider(self.vbox, "SigmaColor", take_odd=False, minimum=0, maximum=self.SIGMA_COLOR_MAX, value=self.sigmaColor) self.sigmaColor_slider.add_value_changed_callback( self.slider1_value_changed) vlayout.addWidget(self.sigmaColor_slider) self.sigmaSpace_slider = ZLabeledSlider(self.vbox, "SigmaSpace", take_odd=False, minimum=0, maximum=self.SIGMA_SPACE_MAX, value=self.sigmaSpace) self.sigmaSpace_slider.add_value_changed_callback( self.slider2_value_changed) vlayout.addWidget(self.sigmaSpace_slider) vlayout.setAlignment(Qt.AlignTop) self.set_right_dock(self.vbox) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.filtered_image_view.load(filename) # Apply filter method to the filtered image view. self.filtered_image_view.filter(self.sigmaColor, self.sigmaSpace) self.set_filenamed_title(filename) def slider1_value_changed(self, value): self.sigmaColor = int(value) #print("SigmaColor:{}".format(self.sigmaColor)) self.filtered_image_view.filter(int(self.sigmaColor), int(self.sigmaSpace)) def slider2_value_changed(self, value): self.sigmaSpace = int(value) #print("SigmaSpace:{}".format(self.sigmaSpace)) self.filtered_image_view.filter(int(self.sigmaColor), int(self.sigmaSpace))
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class DetectedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): source_image = self.load_opencv_image(filename) self.gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) def detect(self, adaptive_method_id, threshold_type_id, block_size, threshold1, threshold2): MAX_PIXEL_VALUE = 255 C = 9.0 adapted_image = cv2.adaptiveThreshold(self.gray_image, MAX_PIXEL_VALUE, adaptive_method_id, threshold_type_id, block_size, C) detected_image = cv2.Canny(adapted_image, threshold1, threshold2) self.set_opencv_image(detected_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/SuperCar2.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.detected_image_view = self.DetectedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add imageviews to the main_layout which is a horizontal layouter. self.add(self.source_image_view) self.add(self.detected_image_view) self.detected_image_view.detect(self.adaptive_method_id, self.threshold_type_id, self.block_size, self.threshold1, self.threshold2) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.block_size = 11 self.vpane = ZVerticalPane(self, fixed_width) self.adaptive_method_id = 0 self.threshold_type_id = 0 self.methods = { "ADAPTIVE_THRESH_MEAN_C": cv2.ADAPTIVE_THRESH_MEAN_C, "ADAPTIVE_THRESH_GAUSSIAN_C": cv2.ADAPTIVE_THRESH_GAUSSIAN_C } self.types = { "THRESH_BINARY": cv2.THRESH_BINARY, "THRESH_BINARY_INV": cv2.THRESH_BINARY_INV } self.adaptive_method = ZLabeledComboBox(self.vpane, "AdaptiveMethod") self.adaptive_method.add_items(list(self.methods.keys())) self.adaptive_method.add_activated_callback( self.adaptive_method_activated) self.threshold_type = ZLabeledComboBox(self.vpane, "ThresholdType") self.threshold_type.add_items(list(self.types.keys())) self.threshold_type.add_activated_callback( self.threshold_type_activated) self.block_size_slider = ZLabeledSlider(self.vpane, "BlockSize", take_odd=True, minimum=3, maximum=43, value=self.block_size, fixed_width=200) self.block_size_slider.add_value_changed_callback( self.block_size_changed) self.vpane.add(self.adaptive_method) self.vpane.add(self.threshold_type) self.vpane.add(self.block_size_slider) self.threshold1 = 50 self.threshold2 = 100 self.threshold1_slider = ZLabeledSlider(self.vpane, "Threshold1", take_odd=True, minimum=0, maximum=300, value=self.threshold1) self.threshold1_slider.add_value_changed_callback( self.slider1_value_changed) self.threshold2_slider = ZLabeledSlider(self.vpane, "Threshold2", take_odd=True, minimum=0, maximum=300, value=self.threshold2) self.threshold2_slider.add_value_changed_callback( self.slider2_value_changed) self.vpane.add(self.threshold1_slider) self.vpane.add(self.threshold2_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.detected_image_view.load(filename) self.detected_image_view.detect(self.adaptive_method_id, self.threshold_type_id, self.block_size, self.threshold1, self.threshold2) self.set_filenamed_title(filename) def block_size_changed(self, value): self.block_size = int(value) if self.block_size % 2 == 0: # Block size should be odd. self.block_size = int((self.block_size * 2) / 2 + 1) #print("block_size_changed:{}".format(block_size)) self.detected_image_view.detect(self.adaptive_method_id, self.threshold_type_id, self.block_size, self.threshold1, self.threshold2) def adaptive_method_activated(self, text): self.adaptive_method_id = self.methods[text] #print("adaptive_method_activated:{}{}".format(text, self.adaptive_method_id)) self.detected_image_view.detect(self.adaptive_method_id, self.threshold_type_id, self.block_size, self.threshold1, self.threshold2) def threshold_type_activated(self, text): self.threshold_type_id = self.types[text] #print("threshold_type_activated:{}{}".format(text, self.threshold_type_id)) self.detected_image_view.detect(self.adaptive_method_id, self.threshold_type_id, self.block_size, self.threshold1, self.threshold2) def slider1_value_changed(self, value): self.threshold1 = int(value) #print("slider1_value_changed:{}".format(value)) self.detected_image_view.detect(self.adaptive_method_id, self.threshold_type_id, self.block_size, self.threshold1, self.threshold2) def slider2_value_changed(self, value): self.threshold2 = int(value) #print("slider2_value_changed:{}".format(value)) self.detected_image_view.detect(self.adaptive_method_id, self.threshold_type_id, self.block_size, self.threshold1, self.threshold2)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class TransformedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) def transform(self, shape_id, ksize): src_image = self.get_opencv_image() element = cv2.getStructuringElement(shape_id, (ksize, ksize), (-1, -1)) transformed_image = cv2.dilate(src_image, element) if transformed_image.all() != None: self.set_opencv_image(transformed_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/HelloWorld.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.transformed_image_view = self.TransformedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.transformed_image_view) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.ksize = 3 self.shape_id = 2 self.shapes = {"MORPH_RECT": 0, "MORPH_CROSS": 1, "MORPH_ELLIPSE": 2} self.shape = ZLabeledComboBox(self.vpane, "AdaptiveMethod") self.shape.add_items(list(self.shapes.keys())) self.shape.add_activated_callback(self.shape_activated) self.ksize_slider = ZLabeledSlider(self.vpane, "KernelSize", take_odd=True, minimum=1, maximum=33, value=self.ksize, fixed_width=200) self.ksize_slider.add_value_changed_callback(self.ksize_value_changed) self.vpane.add(self.shape) self.vpane.add(self.ksize_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.transformed_image_view.load(filename) self.transformed_image_view.transform(self.shape_id, self.ksize) self.set_filenamed_title(filename) def ksize_value_changed(self, value): self.ksize = int(value) if self.ksize % 2 == 0: self.ksize = int((self.ksize * 2) / 2 + 1) # Block size should be odd. #print("ksize_value_changed:{}".format(ksize)) self.transformed_image_view.transform(self.shape_id, self.ksize) def shape_activated(self, text): self.shape_id = self.shapes[text] print("shape_activated:{} {}".format(text, self.shape_id)) self.transformed_image_view.transform(self.shape_id, self.ksize)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class SharpenedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) def sharpen(self, ksize, sigma): source_image = self.get_opencv_image() blurred = cv2.GaussianBlur( source_image, (ksize, ksize), float(sigma), #sigmaX, float(sigma), #sigmaY cv2.BORDER_DEFAULT) alpha = 2.5 beta = 1.0 - alpha sharpened = cv2.addWeighted(source_image, alpha, blurred, beta, 0.0) self.set_opencv_image(sharpened) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/Cloud.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.sharpened_image_view = self.SharpenedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.sharpened_image_view) self.show() def add_control_pane(self, fixed_width=200): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.ksize = 21 self.sigmaSize = 12 self.ksize_slider = ZLabeledSlider(self.vpane, "KernelSize", take_odd=True, minimum=0, maximum=31, value=self.ksize) self.ksize_slider.add_value_changed_callback( self.slider1_value_changed) self.vpane.add(self.ksize_slider) self.sigmaSize_slider = ZLabeledSlider(self.vpane, "SigmaSize", take_odd=False, minimum=0, maximum=30, value=self.sigmaSize) self.sigmaSize_slider.add_value_changed_callback( self.slider2_value_changed) self.vpane.add(self.sigmaSize_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.sharpened_image_view.load(filename) # Apply sharpen method to the sharpened image view. self.sharpened_image_view.sharpen(self.ksize, self.sigmaSize) self.set_filenamed_title(filename) def slider1_value_changed(self, value): self.ksize = int(value) self.sharpened_image_view.sharpen(int(self.ksize), int(self.sigmaSize)) def slider2_value_changed(self, value): self.sigmaSize = int(value) self.sharpened_image_view.sharpen(int(self.ksize), int(self.sigmaSize))
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class DetectedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): source_image = self.load_opencv_image(filename) self.gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) def detect(self, minDist, minArea, maxArea): source_image = self.get_opencv_image() params = cv2.SimpleBlobDetector_Params() params.thresholdStep = 10.0 params.minThreshold = 50.0 params.maxThreshold = 220.0 params.filterByArea = True params.minArea = minArea params.maxArea = maxArea params.filterByColor = True params.blobColor = 0 params.filterByCircularity = True params.minCircularity = 0.5 params.filterByConvexity = True params.minConvexity = 0.8 params.filterByInertia = True params.minInertiaRatio = 0.1 params.minRepeatability = 2 params.minDistBetweenBlobs = 5.0 params.minDistBetweenBlobs = float(minDist) detector = cv2.SimpleBlobDetector_create(params) keypoints = detector.detect(self.gray_image) out_image = cv2.drawKeypoints( source_image, keypoints, None, (0, 0, 255), cv2.DrawMatchesFlags_DRAW_RICH_KEYPOINTS) self.set_opencv_image(out_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/cat.jpg" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.detectd_image_view = self.DetectedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.detectd_image_view) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.minDist = 9 self.minArea = 15 self.maxArea = 131 self.minDistance_slider = ZLabeledSlider(self.vpane, "MinDistanceBetweenBlob", take_odd=False, minimum=5, maximum=100, value=self.minDist, fixed_width=200) self.minDistance_slider.add_value_changed_callback( self.minDistance_value_changed) self.minArea_slider = ZLabeledSlider(self.vpane, "MinArea", take_odd=False, minimum=1, maximum=100, value=self.minArea, fixed_width=200) self.minArea_slider.add_value_changed_callback( self.minArea_value_changed) self.maxArea_slider = ZLabeledSlider(self.vpane, "MaxArea", take_odd=False, minimum=100, maximum=200, value=self.maxArea, fixed_width=200) self.maxArea_slider.add_value_changed_callback( self.maxArea_value_changed) self.vpane.add(self.minDistance_slider) self.vpane.add(self.minArea_slider) self.vpane.add(self.maxArea_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.detectd_image_view.load(filename) self.detectd_image_view.detect(self.minDist, self.minArea, self.maxArea) self.set_filenamed_title(filename) def minDistance_value_changed(self, value): self.minDist = int(value) self.detectd_image_view.detect(self.minDist, self.minArea, self.maxArea) def minArea_value_changed(self, value): self.minArea = int(value) self.detectd_image_view.detect(self.minDist, self.minArea, self.maxArea) def maxArea_value_changed(self, value): self.maxArea = int(value) self.detectd_image_view.detect(self.minDist, self.minArea, self.maxArea)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class DetectedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) def detect(self, hog_descriptor_id, stride): detected_image = self.get_opencv_image().copy() self.hog = None if hog_descriptor_id == MainView.DEFAULT: winSize = (64, 128) blockSize = (16, 16) blockStride = (8, 8) cellSize = (8, 8) nbins = 9 self.hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins) self.hog.setSVMDetector( cv2.HOGDescriptor_getDefaultPeopleDetector()) if hog_descriptor_id == MainView.DAIMLER: winSize = (48, 96) blockSize = (16, 16) blockStride = (8, 8) cellSize = (8, 8) nbins = 9 self.hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins) self.hog.setSVMDetector( cv2.HOGDescriptor_getDaimlerPeopleDetector()) if hog_descriptor_id == MainView.USER_DEFINED: winSize = (32, 64) blockSize = (8, 8) blockStride = (4, 4) cellSize = (4, 4) nbins = 9 self.hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins) self.hog.setSVMDetector( cv2.HOGDescriptor_getDefaultPeopleDetector()) (rectangles, weights) = self.hog.detectMultiScale(detected_image, hitThreshold=0, winStride=(stride, stride), padding=(0, 0), scale=1.05, finalThreshold=2) for (x, y, w, h) in rectangles: cv2.rectangle(detected_image, (x, y), (x + w, y + h), (0, 0, 255), 2) self.set_opencv_image(detected_image) self.update() #-------------------------------------------- DEFAULT = 0 DAIMLER = 1 USER_DEFINED = 2 # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/Pedestrian.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.detected_image_view = self.DetectedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.detected_image_view) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.stride = 6 self.hog_descriptor_id = self.DEFAULT self.hog_descriptors = { "Default": self.DEFAULT, "Daimler": self.DAIMLER, "UserDefined": self.USER_DEFINED } self.hog_descriptor = ZLabeledComboBox(self.vpane, "HOG Descriptor") self.hog_descriptor.add_items(list(self.hog_descriptors.keys())) self.hog_descriptor.add_activated_callback( self.hog_descriptor_activated) self.hog_descriptor.set_current_text(self.hog_descriptor_id) self.stride_slider = ZLabeledSlider(self.vpane, "WinStride", take_odd=False, minimum=1, maximum=16, value=self.stride, fixed_width=180) self.stride_slider.add_value_changed_callback( self.stride_value_changed) self.vpane.add(self.hog_descriptor) self.vpane.add(self.stride_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.detected_image_view.load(filename) self.detected_image_view.detect(self.hog_descriptor_id, self.stride) self.set_filenamed_title(filename) def stride_value_changed(self, value): self.stride = int(value) self.detected_image_view.detect(self.hog_descriptor_id, self.stride) def hog_descriptor_activated(self, text): self.hog_descriptor_id = self.hog_descriptors[text] print("hog_descriptor_activated:{} {}".format(text, self.hog_descriptor_id)) self.detected_image_view.detect(self.hog_descriptor_id, self.stride)
class MainView(ZApplicationView): # Inner classes #--------------------------------------------------------- class BinarizedImageView(ZOpenCVImageView): def __init__(self, parent, filename=None, flags=cv2.IMREAD_COLOR): ZOpenCVImageView.__init__(self, parent, filename, flags) src_mage = self.get_opencv_image() self.gray_image = cv2.cvtColor(src_mage, cv2.COLOR_BGR2GRAY) print("BinarizedImage") self.binarized_image = None def get_binarized_image(self): return self.binarized_image def binarize(self, threshold_type, threshold_value): try: THRESHOLD_VALUE_MAX = 255 _, self.binarized_image = cv2.threshold( self.gray_image, threshold_value, THRESHOLD_VALUE_MAX, threshold_type) #self.update() #print("bin {}".format(self.binarized_image.shape)) return self.binarized_image except: traceback.print_exc() class MatchedImageView(ZOpenCVImageView): def __init__(self, parent, filename=None, flags=cv2.IMREAD_COLOR): ZOpenCVImageView.__init__(self, parent, filename, flags) def set_matched_image(self, image): self.set_opencv_image(image) self.update() def set_image(self, image): self.set_opencv_image(image) self.update() #--------------------------------------------------------- FIRST = 0 SECOND = 1 THIRD = 2 # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) self.filenames = [ "../images/CatImage.png", "../images/CatFace.png", "../images/Blank.png" ] self.image_views = [None, None, None] self.grid = ZGridLayouter(self) flags = cv2.IMREAD_COLOR # 1 Create three image views. self.image_views[self.FIRST] = self.BinarizedImageView( self, self.filenames[self.FIRST], flags) self.image_views[self.SECOND] = self.BinarizedImageView( self, self.filenames[self.SECOND], flags) self.image_views[self.THIRD] = self.MatchedImageView( self, self.filenames[self.THIRD], flags) # 2 Add the image views to the grid layouter. self.grid.add(self.image_views[self.FIRST], 0, 0) self.grid.add(self.image_views[self.SECOND], 0, 1) self.grid.add(self.image_views[self.THIRD], 1, 0, 1, 2) filename = self.filenames[self.FIRST] + " " + self.filenames[ self.SECOND] self.set_filenamed_title(filename) self.show() # Redefined add_file_menu. def add_file_menu(self): # Typical file menu self.file_menu = QMenu('&File', self) self.file_menu.addAction('&New', self.file_new) self.file_menu.addAction('&Open First File', self.first_file_open) self.file_menu.addAction('&Open Second File', self.second_file_open) self.file_menu.addAction('&Save', self.file_save) self.file_menu.addAction('&Save As', self.file_save_as) self.file_menu.addAction('&Quit', self.file_quit) self.menuBar().addMenu(self.file_menu) def add_control_pane(self, fixed_width=200): # Control pane widget self.threshold_value = 11 self.vpane = ZVerticalPane(self, fixed_width) self.threshold_type_id = 0 self.types = { "THRESH_BINARY": cv2.THRESH_BINARY, "THRESH_BINARY_INV": cv2.THRESH_BINARY_INV, "THRESH_TRUNC": cv2.THRESH_TRUNC, "THRESH_TOZERO": cv2.THRESH_TOZERO, "THRESH_TOZERO_INV": cv2.THRESH_TOZERO_INV, "THRESH_OTSU": cv2.THRESH_OTSU, "THRESH_TRIANGLE": cv2.THRESH_TRIANGLE } self.threshold_type = ZLabeledComboBox(self.vpane, "ThresholdType") self.threshold_type.add_items(list(self.types.keys())) self.threshold_type.add_activated_callback( self.threshold_type_activated) self.threshold_type.set_current_text(self.threshold_type_id) self.threshold_value = 60 self.threshold_value_slider = ZLabeledSlider( self.vpane, "ThresholdValue", take_odd=True, minimum=0, maximum=255, value=self.threshold_value, fixed_width=200) self.threshold_value_slider.add_value_changed_callback( self.threshold_value_changed) self.vpane.add(self.threshold_type) self.vpane.add(self.threshold_value_slider) self.match_min_size = 60 self.match_max_size = 240 self.match_min_size_slider = ZLabeledSlider(self.vpane, "MatchMinSize", take_odd=True, minimum=10, maximum=100, value=self.match_min_size) self.match_min_size_slider.add_value_changed_callback( self.match_min_size_value_changed) self.match_max_size_slider = ZLabeledSlider(self.vpane, "MatchMaxSize", take_odd=True, minimum=100, maximum=400, value=self.match_max_size) self.match_max_size_slider.add_value_changed_callback( self.match_max_size_value_changed) self.vpane.add(self.match_min_size_slider) self.vpane.add(self.match_max_size_slider) self.clear_button = QPushButton("Clear", self.vpane) self.clear_button.clicked.connect(self.clear_button_clicked) self.match_button = QPushButton("Match", self.vpane) self.match_button.clicked.connect(self.match_button_clicked) self.vpane.add(self.clear_button) self.vpane.add(self.match_button) self.set_right_dock(self.vpane) def first_file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.filenames[self.FIRST] = filename self.image_views[self.FIRST].load_opencv_image(filename) self.image_views[self.THIRD].load_opencv_image( self.filenames[self.THIRD]) filename = self.filenames[self.FIRST] + " " + self.filenames[ self.SECOND] self.set_filenamed_title(filename) def second_file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.filenames[self.SECOND] = filename self.image_views[self.SECOND].load_opencv_image(filename) self.image_views[self.THIRD].load_opencv_image( self.filenames[self.THIRD]) filename = self.filenames[self.FIRST] + " " + self.filenames[ self.SECOND] self.set_filenamed_title(filename) def threshold_type_activated(self, text): self.threshold_type_id = self.types[text] self.shapeMatching() def threshold_value_changed(self, value): self.threshold_value = int(value) if self.threshold_value % 2 == 0: # Block size should be odd. self.threshold_value = int((self.threshold_value * 2) / 2 + 1) self.shapeMatching() def match_min_size_value_changed(self, value): self.match_min_size = int(value) self.shapeMatching() def match_max_size_value_changed(self, value): self.match_max_size = int(value) self.shapeMatching() def clear_button_clicked(self): src_image = self.image_views[self.FIRST].get_opencv_image().copy() self.image_views[self.THIRD].set_image(src_image) def match_button_clicked(self): self.shapeMatching() # Shape matching operation to two images in image_views[self.FIRST] and image_views[self.SECOND]. # A matched rectangle will be draw on image_views[self.THIRD]. def shapeMatching(self): src_image = self.image_views[self.FIRST].get_opencv_image().copy() self.image_views[self.THIRD].set_image(src_image) src_bin = self.image_views[self.FIRST].binarize( self.threshold_type_id, self.threshold_value) tmp_bin = self.image_views[self.SECOND].binarize( self.threshold_type_id, self.threshold_value) nlabels, labels, stats, centroids = cv2.connectedComponentsWithStats( src_bin) print("labels:{}".format(nlabels)) dest_image = src_image.copy() MATCHING_THRESHOLD = 0.005 minimum = [0, 0, 0, 0] #cv2.Rect(0, 0, 0, 0) MIN_SIMILARITY = 1.0 found = False CV_CONTOURS_MATCH_I1 = 1 for i in range(nlabels): x, y, w, h, a = stats[i] rect = [x, y, w, h] # Region of interest roi = src_bin[y:(y + h), x:(x + w)] similarity = cv2.matchShapes( tmp_bin, roi, CV_CONTOURS_MATCH_I1, 0) #method=CV_CONTOURS_MATCH_I1, parameter=0); if ((w >= self.match_min_size or h >= self.match_min_size) and (w <= self.match_max_size or h <= self.match_max_size)): if (similarity <= MIN_SIMILARITY): MIN_SIMILARITY = similarity minimum = rect print("matching similarity={} x={} y={} w={} h={}".format( similarity, x, y, w, h)) found = True if found: x, y, w, h = minimum cv2.rectangle(dest_image, (x, y), (x + w, y + h), (0, 0, 255), 3) self.image_views[self.THIRD].set_matched_image(dest_image)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class DetectedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) self.gray_image = None def load(self, filename): self.load_opencv_image(filename) source_image = self.get_opencv_image() self.gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) def detect(self, threshold1, threshold2): source_image = self.get_opencv_image() #1 Apply cv::Canny to the grayImage to get edges in the grayImage. detected_image = cv2.Canny(self.gray_image, threshold1=float(threshold1), threshold2=float(threshold2), apertureSize=3) #2 Apply HoughLinesP to detectedImage returned by cv::Canny. minLineLength = 100 maxLineGap = 10 lines = cv2.HoughLinesP(detected_image, rho=1, theta=np.pi / 180, threshold=80, minLineLength=30, maxLineGap=10) #3 Put a clone of the source_image to the detected_image, detected_image = source_image.copy() #4 Draw lines on the clone of the original image. if lines is not None: for line in lines: #In case of OpenCV3.4 x1, y1, x2, y2 = line[0] print(x1, y1, x2, y2) cv2.line(detected_image, (x1, y1), (x2, y2), (0, 255, 0), 2) self.set_opencv_image(detected_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/GinzaWako.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.detected_image_view = self.DetectedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.detected_image_view) self.show() def add_control_pane(self, fixed_width=200): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.threshold1 = 120 self.threshold2 = 130 self.threshold1_slider = ZLabeledSlider(self.vpane, "Threshold1", take_odd=True, minimum=0, maximum=300, value=self.threshold1) self.threshold1_slider.add_value_changed_callback( self.slider1_value_changed) self.vpane.add(self.threshold1_slider) self.threshold2_slider = ZLabeledSlider(self.vpane, "Threshold2", take_odd=True, minimum=0, maximum=300, value=self.threshold2) self.threshold2_slider.add_value_changed_callback( self.slider2_value_changed) self.vpane.add(self.threshold2_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.detected_image_view.load(filename) # Apply detect method to the detected image view. self.detected_image_view.detect(self.threshold1, self.threshold2) self.set_filenamed_title(filename) def slider1_value_changed(self, value): self.threshold1 = int(value) self.detected_image_view.detect(int(self.threshold1), int(self.threshold2)) def slider2_value_changed(self, value): self.threshold2 = int(value) self.detected_image_view.detect(int(self.threshold1), int(self.threshold2))
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class ConvertedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) def convert(self, alpha, beta): source_image = self.get_opencv_image() result = source_image.copy() cv2.convertScaleAbs(source_image, result, alpha, beta) self.set_opencv_image(result) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/Cloud.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.converted_image_view = self.ConvertedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.converted_image_view) self.show() def add_control_pane(self, fixed_width=200): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.contrast = 1 self.brightness = 11 self.contrast_slider = ZLabeledSlider(self.vpane, "Color", take_odd=False, minimum=1, maximum=3, value=self.contrast) self.contrast_slider.add_value_changed_callback( self.slider1_value_changed) self.vpane.add(self.contrast_slider) self.brightness_slider = ZLabeledSlider(self.vpane, "Contrast", take_odd=False, minimum=0, maximum=100, value=self.brightness) self.brightness_slider.add_value_changed_callback( self.slider2_value_changed) self.vpane.add(self.brightness_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.converted_image_view.load(filename) # Apply convert method to the converted image view. self.converted_image_view.convert(self.contrast, self.brightness) self.set_filenamed_title(filename) def slider1_value_changed(self, value): self.contrast = int(value) self.converted_image_view.convert(int(self.contrast), int(self.brightness)) def slider2_value_changed(self, value): self.brightness = int(value) self.converted_image_view.convert(int(self.contrast), int(self.brightness))
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class BlurredImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): source_image = self.load_opencv_image(filename) self.gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) def blur(self, diameter, sigma_color, sigma_space): source_image = self.get_opencv_image() print("blur {} {} {}".format(diameter, sigma_color, sigma_space)) blurred_image = cv2.bilateralFilter(source_image, diameter, float(sigma_color), float(sigma_space)) self.set_opencv_image(blurred_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/MeshedNioh.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.blurred_image_view = self.BlurredImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.blurred_image_view) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.diameter = 4 self.sigma_color = 160 self.sigma_space = 40 self.diameter_slider = ZLabeledSlider(self.vpane, "Diameter", take_odd=False, minimum=0, maximum=5, value=self.diameter, fixed_width=200) self.diameter_slider.add_value_changed_callback( self.diameter_value_changed) self.sigma_color_slider = ZLabeledSlider(self.vpane, "SigmaColor", take_odd=False, minimum=0, maximum=255, value=self.sigma_color, fixed_width=200) self.sigma_color_slider.add_value_changed_callback( self.sigma_color_value_changed) self.sigma_space_slider = ZLabeledSlider(self.vpane, "SigmaSpace", take_odd=False, minimum=0, maximum=255, value=self.sigma_space, fixed_width=200) self.sigma_space_slider.add_value_changed_callback( self.sigma_space_value_changed) self.vpane.add(self.diameter_slider) self.vpane.add(self.sigma_color_slider) self.vpane.add(self.sigma_space_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.blurred_image_view.load(filename) self.blurred_image_view.blur(self.diameter, self.sigma_color, self.sigma_space) self.set_filenamed_title(filename) def diameter_value_changed(self, value): self.diameter = int(value) self.blurred_image_view.blur(self.diameter, self.sigma_color, self.sigma_space) def sigma_color_value_changed(self, value): self.sigma_color = int(value) self.blurred_image_view.blur(self.diameter, self.sigma_color, self.sigma_space) def sigma_space_value_changed(self, value): self.sigma_space = int(value) self.blurred_image_view.blur(self.diameter, self.sigma_color, self.sigma_space)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class BinarizedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): source_image = self.load_opencv_image(filename) image = cv2.GaussianBlur(source_image, (3,3), 0, 0, borderType = cv2.BORDER_DEFAULT ); self.gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) def binarize(self, adaptive_method_id, threshold_type_id, block_size): MAX_PIXEL_VALUE = 255 C = 9.0 binarizered_image = cv2.adaptiveThreshold(self.gray_image, MAX_PIXEL_VALUE, adaptive_method_id, threshold_type_id, block_size, C); self.set_opencv_image(binarizered_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "images/flower.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.binarized_image_view = self.BinarizedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.binarized_image_view) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.vpane = ZVerticalPane(self, fixed_width) self.block_size = 11 self.adaptive_method_id = 0; self.threshold_type_id = 0; self.methods = {"ADAPTIVE_THRESH_MEAN_C": cv2.ADAPTIVE_THRESH_MEAN_C, "ADAPTIVE_THRESH_GAUSSIAN_C": cv2.ADAPTIVE_THRESH_GAUSSIAN_C} self.types = {"THRESH_BINARY": cv2.THRESH_BINARY , "THRESH_BINARY_INV": cv2.THRESH_BINARY_INV } self.adaptive_method = ZLabeledComboBox(self.vpane, "AdaptiveMethod") self.adaptive_method.add_items(list(self.methods.keys() )) self.adaptive_method.add_activated_callback(self.adaptive_method_activated) self.threshold_type = ZLabeledComboBox(self.vpane, "ThresholdType") self.threshold_type.add_items(list(self.types.keys()) ) self.threshold_type.add_activated_callback(self.threshold_type_activated) self.labeled_slider = ZLabeledSlider(self.vpane, "BlockSize", take_odd =True, minimum=3, maximum=43, value=self.block_size, fixed_width=200) self.labeled_slider.add_value_changed_callback(self.slider_value_changed) self.vpane.add(self.adaptive_method) self.vpane.add(self.threshold_type) self.vpane.add(self.labeled_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName(self,"FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.binarized_image_view.load(filename) self.binarized_image_view.binarize(self.adaptive_method_id, self.threshold_type_id, self.block_size) self.set_filenamed_title(filename) def slider_value_changed(self, value): self.block_size = int(value) if self.block_size % 2 == 0: # Block size should be odd. self.block_size = int((self.block_size * 2)/2 + 1) #print("slider_value_changed:{}".format(block_size)) self.binarized_image_view.binarize(self.adaptive_method_id, self.threshold_type_id, self.block_size) def adaptive_method_activated(self, text): #print("adaptive_method_activated:{}".format(text)) self.adaptive_method_id = self.methods[text] self.binarized_image_view.binarize(self.adaptive_method_id, self.threshold_type_id, self.block_size) def threshold_type_activated(self, text): #print("threshold_type_activated:{}".format(text)) self.threshold_type_id = self.types[text] self.binarized_image_view.binarize(self.adaptive_method_id, self.threshold_type_id, self.block_size)
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class DetectedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): source_image = self.load_opencv_image(filename) self.gray_image = cv2.cvtColor(source_image, cv2.COLOR_RGB2GRAY) def detect(self, ksize): ksize = int(ksize) gradX = cv2.Sobel(self.gray_image, -1, 1, 0, ksize=ksize) gradY = cv2.Sobel(self.gray_image, -1, 0, 1, ksize=ksize) absGradX = cv2.convertScaleAbs(gradX) absGradY = cv2.convertScaleAbs(gradY) detected_image = cv2.addWeighted(absGradX, 0.5, absGradY, 0.5, 0) self.set_opencv_image(detected_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/ClassicCar.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.detected_image_view = self.DetectedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.detected_image_view) self.show() # Add control pane to MainView def add_control_pane(self, fixed_width=200): # Control pane widget self.ksize = 5 self.vpane = ZVerticalPane(self, fixed_width) self.labeled_slider = ZLabeledSlider(self.vpane, "KernelSize", take_odd=True, minimum=0, maximum=33, value=self.ksize) self.labeled_slider.add_value_changed_callback( self.slider_value_changed) self.vpane.add(self.labeled_slider) self.set_right_dock(self.vpane) # Show FileOpenDialog and select an image file. def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.detected_image_view.load(filename) self.detected_image_view.detect(int(self.ksize)) self.set_filenamed_title(filename) # Slider value changed callback. def slider_value_changed(self, value): self.ksize = int(value) if self.ksize % 2 == 0: self.ksize = (self.ksize * 2) / 2 + 1 # Kernel size should be odd. print("slider_value_changed:{}".format(self.ksize)) self.detected_image_view.detect(int(int(self.ksize)))
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_openv_image(filename) self.update() class BlurredImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_openv_image(filename) def blur(self, ksize): ksize = int(ksize) original_image = self.get_opencv_image() blurred_image = cv2.medianBlur(original_image, ksize) self.set_opencv_image(blurred_image) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/flower.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.blurred_image_view = self.BlurredImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.blurred_image_view) self.show() # Add control pane to MainView def add_control_pane(self, fixed_width=200): # Create a vertical control pane. self.vpane = ZVerticalPane(self, fixed_width) self.ksize = 11 self.labeled_slider = ZLabeledSlider(self.vpane, "KernelSize", take_odd=True, minimum=0, maximum=33, value=self.ksize) self.labeled_slider.add_value_changed_callback( self.slider_value_changed) self.vpane.add(self.labeled_slider) # Set the control_pane to the right docking area of this main window. self.set_right_dock(self.vpane) # Show FileOpenDialog and select an image file. def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load_opencv_image(filename, cv2.IMREAD_COLOR) self.blurred_image_view.load_opencv_image(filename, cv2.IMREAD_COLOR) self.blurred_image_view.blur(int(self.ksize)) self.set_filenamed_title(filename) # Slider value changed callback. def slider_value_changed(self, value): self.ksize = int(value) if self.ksize % 2 == 0: self.ksize = (self.ksize * 2) / 2 + 1 # Kernel size should be odd. #print("slider_value_changed:{}".format(ksize)) self.blurred_image_view.blur(int(int(self.ksize)))
class MainView(ZApplicationView): # Inner classes #-------------------------------------------- class SourceImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): self.load_opencv_image(filename) self.update() class BinarizedImageView(ZOpenCVImageView): def __init__(self, parent): ZOpenCVImageView.__init__(self, parent) def load(self, filename): image = self.load_opencv_image(filename) self.source_image = image.copy() #self.gray_image = cv2.cvtColor(self.source_image, cv2.COLOR_RGB2GRAY) self.gray_image = cv2.cvtColor(self.source_image, cv2.COLOR_BGR2GRAY) def binarize(self, adaptive_method_id, threshold_type_id, block_size): MAX_PIXEL_VALUE = 255 C = 9.0 self.binarizered_image = cv2.adaptiveThreshold( self.gray_image, MAX_PIXEL_VALUE, adaptive_method_id, threshold_type_id, block_size, C) #self.set_opencv_image(binarizered_image) self.update() def detect_connected_components(self): target = self.source_image.copy() nlabels, labels, stats, centroids = cv2.connectedComponentsWithStats( self.binarizered_image, 4) #stats = cv2.connectedComponentsWithStats(self.gray_image) print("labels:{}".format(nlabels)) ih, iw, c = target.shape print("target:width={} height={} channels={}".format(iw, ih, c)) for i in range(nlabels): x, y, w, h, a = stats[i] print("x,y,w,h, a={},{},{},{}, {}".format(x, y, w, h, a)) cv2.rectangle(target, (x, y), (x + w, y + h), (0, 0, 255), 3) self.set_opencv_image(target) self.update() #-------------------------------------------- # MainView Constructor def __init__(self, title, x, y, width, height): super(MainView, self).__init__(title, x, y, width, height) filename = "../images/Shapes.png" # 1 Create first imageview. self.source_image_view = self.SourceImageView(self) # 2 Create second imageview. self.binarized_image_view = self.BinarizedImageView(self) # 3 Load the file self.load_file(filename) # 4 Add two image views to a main_layout of this main view. self.add(self.source_image_view) self.add(self.binarized_image_view) self.show() def add_control_pane(self, fixed_width=220): # Control pane widget self.block_size = 11 self.vpane = ZVerticalPane(self, fixed_width) self.adaptive_method_id = 0 self.threshold_type_id = 0 self.methods = { "ADAPTIVE_THRESH_MEAN_C": cv2.ADAPTIVE_THRESH_MEAN_C, "ADAPTIVE_THRESH_GAUSSIAN_C": cv2.ADAPTIVE_THRESH_GAUSSIAN_C } self.types = { "THRESH_BINARY": cv2.THRESH_BINARY, "THRESH_BINARY_INV": cv2.THRESH_BINARY_INV } self.adaptive_method = ZLabeledComboBox(self.vpane, "AdaptiveMethod") self.adaptive_method.add_items(list(self.methods.keys())) self.adaptive_method.add_activated_callback( self.adaptive_method_activated) self.threshold_type = ZLabeledComboBox(self.vpane, "ThresholdType") self.threshold_type.add_items(list(self.types.keys())) self.threshold_type.add_activated_callback( self.threshold_type_activated) self.labeled_slider = ZLabeledSlider(self.vpane, "BlockSize", take_odd=True, minimum=3, maximum=43, value=self.block_size, fixed_width=200) self.labeled_slider.add_value_changed_callback( self.slider_value_changed) self.vpane.add(self.adaptive_method) self.vpane.add(self.threshold_type) self.vpane.add(self.labeled_slider) self.set_right_dock(self.vpane) def file_open(self): options = QFileDialog.Options() filename, _ = QFileDialog.getOpenFileName( self, "FileOpenDialog", "", "All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options) if filename: self.load_file(filename) def load_file(self, filename): self.source_image_view.load(filename) self.binarized_image_view.load(filename) self.binarized_image_view.binarize(self.adaptive_method_id, self.threshold_type_id, self.block_size) self.binarized_image_view.detect_connected_components() self.set_filenamed_title(filename) def slider_value_changed(self, value): self.block_size = int(value) if self.block_size % 2 == 0: self.block_size = int((self.block_size * 2) / 2 + 1) # Block size should be odd. print("slider_value_changed:{}".format(self.block_size)) self.binarized_image_view.binarize(self.adaptive_method_id, self.threshold_type_id, self.block_size) self.binarized_image_view.detect_connected_components() def adaptive_method_activated(self, text): print("adaptive_method_activated:{}".format(text)) self.adaptive_method_id = self.methods[text] self.binarized_image_view.binarize(self.adaptive_method_id, self.threshold_type_id, self.block_size) self.binarized_image_view.detect_connected_components() def threshold_type_activated(self, text): print("threshold_type_activated:{}".format(text)) self.threshold_type_id = self.types[text] self.binarized_image_view.binarize(self.adaptive_method_id, self.threshold_type_id, self.block_size) self.binarized_image_view.detect_connected_components()