class MainView(ZApplicationView):
class BinarizedImageView(ZOpenCVImageView):
def __init__(self, parent):
ZOpenCVImageView.__init__(self, parent)
# Constructor
def __init__(self, title, x, y, width, height):
super(MainView, self).__init__(title, x, y, width, height)
self.raw_video_queue = mp.Queue()
self.to_binarize_video_queue = mp.Queue()
self.binarized_video_queue = mp.Queue()
# Binarize initial settings
#self.block_size = 11
#self.adaptive_method_id = 0;
#self.threshold_type_id = 0;
self.binarize_video_settings_queue = mp.Queue()
#binarize_video_settings_queue.put_nowait((self.block_size, \
# self.adaptive_method_id, \
# self.threshold_type_id))
self.time_snapshot_seconds = None # initialized to None . Used for rate limiting processing pipelines
self.processing_rate_limit_hz = 20 # 30 Hz seems to be about the maximum if this camera
self.raw_image_view = ZOpenCVImageView(self)
self.binarized_image_view = self.BinarizedImageView(self)
self.add(self.raw_image_view)
self.add(self.binarized_image_view)
title = name
self.setWindowTitle(title)
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 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)
settings = (self.adaptive_method_id, self.threshold_type_id,
self.block_size)
self.binarize_video_settings_queue.put_nowait(settings)
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)
settings = (self.adaptive_method_id, self.threshold_type_id,
self.block_size)
self.binarize_video_settings_queue.put_nowait(settings)
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)
settings = (self.adaptive_method_id, self.threshold_type_id,
self.block_size)
self.binarize_video_settings_queue.put_nowait(settings)
# Read a frame from a video buffer of the video capture, and set it the image view to draw it on the imag view
def render(self):
return_true = False
#return_true = True
#"""
if not self.raw_video_queue.empty():
raw_frame = self.raw_video_queue.get_nowait()
if raw_frame.any() != None:
self.raw_image_view.set_opencv_image(raw_frame)
self.raw_image_view.update()
# Send frame to processing queue
# rate limited
current_time_seconds = time()
if self.time_snapshot_seconds == None:
self.time_snapshot_seconds = current_time_seconds
if current_time_seconds > self.time_snapshot_seconds: # Avoid dividing by zero
#print(1/(current_time_seconds-self.time_snapshot_seconds))
if ((1 /
(current_time_seconds - self.time_snapshot_seconds))
<= self.processing_rate_limit_hz): # Rate limit
#print("Sending raw frame for further processing!")
self.to_binarize_video_queue.put_nowait(raw_frame)
self.time_snapshot_seconds = current_time_seconds
return_true = True
if not self.binarized_video_queue.empty():
binarized_frame = self.binarized_video_queue.get_nowait()
if binarized_frame.any() != None:
self.binarized_image_view.set_opencv_image(binarized_frame)
self.binarized_image_view.update()
return_true = True
#"""
if return_true:
return True
else:
return False
def file_quit(self):
self.terminated = True
def closeEvent(self, ce):
self.terminated = True
class MainView(ZApplicationView):
# Class variables
# ClassifierView Constructor
def __init__(self, title, x, y, width, height):
super(MainView, self).__init__(title, x, y, width, height)
self.font = QFont("Arial", 10)
self.setFont(self.font)
# 1 Add a labeled combobox to top dock area
self.add_datasets_combobox()
# 2 Add a textedit to the left pane of the center area.
self.text_editor = QTextEdit()
self.text_editor.setLineWrapColumnOrWidth(600)
self.text_editor.setLineWrapMode(QTextEdit.FixedPixelWidth)
# 3 Add a description to display dataset.DESCR.
self.description = QTextEdit()
self.description.setLineWrapColumnOrWidth(600)
self.description.setLineWrapMode(QTextEdit.FixedPixelWidth)
# 4 Add a tabbed_window to the tabbed_window.
self.tabbed_window = ZTabbedWindow(self, 0, 0, width / 2, height)
# 5 Add a figure_view to the tabbed_window.
self.figure_view = ZScalableScrolledFigureView(self, 0, 0, width / 2,
height)
self.add(self.text_editor)
self.add(self.tabbed_window)
self.tabbed_window.add("Description", self.description)
self.tabbed_window.add("ConfusionMatrix", self.figure_view)
self.figure_view.hide()
self.show()
def add_datasets_combobox(self):
self.dataset_id = Iris
self.datasets_combobox = ZLabeledComboBox(self, "Datasets",
Qt.Horizontal)
# We use the following datasets of sklearn to test XGBClassifier.
self.datasets = {
"Iris": Iris,
"Digits": Digits,
"Wine": Wine,
"BreastCancer": BreastCancer
}
title = self.get_title()
self.setWindowTitle("Iris" + " - " + title)
self.datasets_combobox.add_items(self.datasets.keys())
self.datasets_combobox.add_activated_callback(self.datasets_activated)
self.datasets_combobox.set_current_text(self.dataset_id)
self.start_button = ZPushButton("Start", self)
self.clear_button = ZPushButton("Clear", self)
self.start_button.add_activated_callback(self.start_button_activated)
self.clear_button.add_activated_callback(self.clear_button_activated)
self.datasets_combobox.add(self.start_button)
self.datasets_combobox.add(self.clear_button)
self.set_top_dock(self.datasets_combobox)
def write(self, text):
self.text_editor.append(text)
self.text_editor.repaint()
def datasets_activated(self, text):
self.dataset_id = self.datasets[text]
title = self.get_title()
self.setWindowTitle(text + " - " + title)
def start_button_activated(self, text):
self.model = LightGBMClassifierModel(self.dataset_id, self)
self.start_button.setEnabled(False)
self.clear_button.setEnabled(False)
try:
self.model.run()
except:
pass
self.start_button.setEnabled(True)
self.clear_button.setEnabled(True)
def clear_button_activated(self, text):
self.text_editor.setText("")
self.description.setText("")
self.figure_view.hide()
plt.close()
def visualize(self, cmatrix):
self.figure_view.show()
plt.close()
sns.set()
df = pd.DataFrame(cmatrix)
sns.heatmap(df, annot=True, fmt="d")
# Set a new figure to the figure_view.
self.figure_view.set_figure(plt)
class ZImageClassifierView(ZApplicationView):
# Class variables
# ClassifierView Constructor
def __init__(self, title, x, y, width, height, datasets={"ImageModel": 0}):
super(ZImageClassifierView, self).__init__(title, x, y, width, height)
self.font = QFont("Arial", 10)
self.setFont(self.font)
self.datasets = datasets
self.model_loaded = False
self.class_names_set = [None, None]
# Image filename to be classified
self.filename = None
# Target image to be classified
self.image = None
# 1 Add a labeled combobox to top dock area
self.add_datasets_combobox()
# 2 Add a textedit to the left pane of the center area.
self.text_editor = QTextEdit()
self.text_editor.setLineWrapColumnOrWidth(600)
self.text_editor.setLineWrapMode(QTextEdit.FixedPixelWidth)
self.text_editor.setGeometry(0, 0, width/2, height)
# 3 Add a tabbed_window the rigth pane of the center area.
self.tabbed_window = ZTabbedWindow(self, 0, 0, width/2, height)
# 4 Add a imageview to the tabbed_window.
self.image_view = ZScalableScrolledImageView(self, 0, 0, width/3, height/3)
self.tabbed_window.add("SourceImage", self.image_view)
# 5 Add a test_imageview to the right pane of the center area.
self.test_image_view = ZScalableScrolledImageView(self, 0, 0, width/3, height/3)
self.tabbed_window.add("TestImage", self.test_image_view)
self.add(self.text_editor)
self.add(self.tabbed_window)
def add_datasets_combobox(self):
datasetkey = list(self.datasets.keys())[0]
self.dataset_id = self.datasets[datasetkey]
print("Current combobox item {} {}".format(datasetkey, self.dataset_id))
self.datasets_combobox = ZLabeledComboBox(self, "Datasets", Qt.Horizontal)
self.datasets_combobox.setFont(self.font)
title = self.get_title()
self.setWindowTitle(self.__class__.__name__ + " - " + title)
self.datasets_combobox.add_items(self.datasets.keys())
self.datasets_combobox.add_activated_callback(self.datasets_activated)
self.datasets_combobox.set_current_text(self.dataset_id)
self.classifier_button = ZPushButton("Classify", self)
self.classifier_button.setEnabled(False)
self.clear_button = ZPushButton("Clear", self)
self.classifier_button.add_activated_callback(self.classifier_button_activated)
self.clear_button.add_activated_callback(self.clear_button_activated)
self.datasets_combobox.add(self.classifier_button)
self.datasets_combobox.add(self.clear_button)
self.set_top_dock(self.datasets_combobox)
def write(self, text):
self.text_editor.append(text)
self.text_editor.repaint()
def datasets_activated(self, text):
pass
# Show FileOpenDialog and select an image file.
def file_open(self):
if self.model_loaded:
options = QFileDialog.Options()
filename, _ = QFileDialog.getOpenFileName(self,"FileOpenDialog", "",
"All Files (*);;Image Files (*.png;*jpg;*.jpeg)", options=options)
if filename:
self.filename = filename
self.load_file(filename)
self.classifier_button.setEnabled(True)
else:
QMessageBox.warning(self, "ImageClassifier: Weight File Missing",
"Please run: python RoadSignsModel.py " + str(self.dataset_id))
def remove_alpha_channel(self, array):
shape = array.shape
if len(shape) ==3:
w, h, c = shape
if c == 4:
#(w, h, 4) -> (w, h, 3)
#print("Remove the alpha channel of array")
array = array[:,:,:3]
return array
def load_file(self, filename):
from keras.preprocessing.image import load_img, img_to_array
try:
image_cropper = ZPILImageCropper(filename)
# 1 Crop larget_central square region from an image of filename.
cropped_image = image_cropper.crop_largest_central_square_region()
# 2 Load an image from the cropped_fle.
self.image_view.set_image(img_to_array(cropped_image))
self.image_view.update_scale()
self.set_filenamed_title(filename)
# 3 Resize the cropped_image
self.image = cropped_image.resize(self.image_size)
# 4 Convert the self.image to numpy ndarray and remove alpha channel.
self.image = self.remove_alpha_channel(img_to_array(self.image))
# 5 Set self.nadarryy to the test_image_view.
self.test_image_view.set_image(self.image)
# 6 Convert self.image in range[0-1.0]
self.image = self.image.astype('float32')/255.0
# 7 Expand the dimension of the self.image
self.image = np.expand_dims(self.image, axis=0)
#print(self.image.shape)
except:
self.write(formatted_traceback())
def classifier_button_activated(self, text):
self.classifier_button.setEnabled(False)
self.clear_button.setEnabled(False)
try:
self.classify()
except:
self.write(formatted_traceback())
self.classifier_button.setEnabled(True)
self.clear_button.setEnabled(True)
def get_top_five(self, predictions, classes, K=5):
pred = predictions[0]
indices = np.argpartition(pred, -K)[-K:]
results = []
for i in indices:
results.append([pred[i], classes[i]])
results = sorted(results, reverse=True)
return results
def get_class_names(self, path="./class_names.txt"):
classes = []
with open(path, "r") as file:
classes = [s.strip() for s in file.readlines()]
return classes
def classify(self):
self.write("------------------------------------------------------------")
self.write("classify start")
self.write(self.filename)
prediction = self.model.predict(self.image)
pred = np.argmax(prediction, axis=1)
#self.write("Prediction: index " + str(pred))
class_names = self.model.classes
if pred >0 or pred <len(class_names):
self.write("Prediction:" + class_names[int(pred)])
self.write("classify end")
def clear_button_activated(self, text):
self.text_editor.setText("")
pass
class MainView(ZApplicationView):
# MainView Constructor
def __init__(self, title, x, y, width, height):
super(MainView, self).__init__(title, x, y, width, height)
self.font = QFont("Arial", 10)
self.setFont(self.font)
# 1 Add a labeled combobox to top dock area
self.add_datasets_combobox()
# 2 Add a textedit to the left pane of the center area.
self.text_editor = QTextEdit()
self.text_editor.setFont(self.font)
self.text_editor.setLineWrapColumnOrWidth(600)
self.text_editor.setLineWrapMode(QTextEdit.FixedPixelWidth)
self.description = QTextEdit()
self.description.setFont(self.font)
self.description.setLineWrapColumnOrWidth(600)
self.description.setLineWrapMode(QTextEdit.FixedPixelWidth)
# 3 Add a tabbled_window to the right pane of the center area.
self.tabbed_window = ZTabbedWindow(self, 0, 0, width/2, height)
# 4 Add a figure_view to the tabbed_window
self.figure_view = ZScalableScrolledFigureView(self, 0, 0, width/2, height)
self.add(self.text_editor)
self.add(self.tabbed_window)
self.tabbed_window.add("Description", self.description)
self.tabbed_window.add("Importances", self.figure_view)
self.figure_view.hide()
self.show()
def add_datasets_combobox(self):
self.dataset_id = Boston
self.datasets_combobox = ZLabeledComboBox(self, "Datasets", Qt.Horizontal)
# We use the following datasets of sklearn to test RandomForestRegressor.
self.datasets = {"Boston": Boston, "Diabetes": Diabetes}
title = self.get_title()
self.setWindowTitle( "Boston" + " - " + title)
self.datasets_combobox.add_items(self.datasets.keys())
self.datasets_combobox.add_activated_callback(self.datasets_activated)
self.datasets_combobox.set_current_text(self.dataset_id)
self.start_button = ZPushButton("Start", self)
self.clear_button = ZPushButton("Clear", self)
self.start_button.add_activated_callback(self.start_button_activated)
self.clear_button.add_activated_callback(self.clear_button_activated)
self.datasets_combobox.add(self.start_button)
self.datasets_combobox.add(self.clear_button)
self.set_top_dock(self.datasets_combobox)
def write(self, text):
self.text_editor.append(text)
self.text_editor.repaint()
def datasets_activated(self, text):
self.dataset_id = self.datasets[text]
title = self.get_title()
self.setWindowTitle(text + " - " + title)
def start_button_activated(self, text):
self.model = RandomForestRegressorModel(self.dataset_id, self)
self.start_button.setEnabled(False)
self.clear_button.setEnabled(False)
try:
self.model.run()
except:
pass
self.start_button.setEnabled(True)
self.clear_button.setEnabled(True)
def file_new(self):
self.text_editor.setText("")
self.description.setText("")
self.figure_view.hide()
plt.close()
def clear_button_activated(self, text):
self.file_new()
def visualize(self, importances):
self.figure_view.show()
plt.close()
plt.title("Importances in Regression Model")
importances.plot(kind = "barh")
self.figure_view.set_figure( plt)
class MainView(ZApplicationView):
class BinarizedImageView(ZOpenCVImageView):
def __init__(self, parent):
ZOpenCVImageView.__init__(self, parent)
def load_source_image(self, source_image):
image = cv2.GaussianBlur(source_image, (3,3), 0, 0, borderType = cv2.BORDER_DEFAULT );
#image = cv2.GaussianBlur(source_image, (3,3), 0, 0)
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
binarized_image = cv2.adaptiveThreshold(self.gray_image, MAX_PIXEL_VALUE,
adaptive_method_id, threshold_type_id, block_size, C);
#return binarized_image
self.set_opencv_image(binarized_image)
self.update()
# Constructor
def __init__(self, title, x, y, width, height):
super(MainView, self).__init__(title, x, y, width, height)
self.raw_video_queue = mp.Queue()
self.raw_image_view = ZOpenCVImageView(self)
self.binarized_image_view = self.BinarizedImageView(self)
self.add(self.raw_image_view)
self.add(self.binarized_image_view)
title = name
self.setWindowTitle(title)
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 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)
# Read a frame from a video buffer of the video capture, and set it the image view to draw it on the imag view
def render(self):
#return_true = False
if not self.raw_video_queue.empty():
raw_frame = self.raw_video_queue.get_nowait()
if raw_frame.any() != None:
self.raw_image_view.set_opencv_image(raw_frame)
self.raw_image_view.update()
self.binarized_image_view.load_source_image(raw_frame)
self.binarized_image_view.binarize(self.adaptive_method_id, self.threshold_type_id, self.block_size)
return True
"""
if not self.binarized_video_queue.empty():
binarized_frame = self.binarized_video_queue.get_notwait()
if binarized_frame.any() != None:
self.binarized_image_view.set_opencv_image(binarized_frame)
self.binarized_image_view.update()
return_true = True
if return_true:
return True
else:
return False
"""
return False
"""
def load_file(self, filename):
self.image_view_3.load(filename)
self.set_filenamed_title(filename)
"""
def file_quit(self):
self.terminated = True
def closeEvent(self, ce):
self.terminated = True