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()