class Window(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle(
"Pyside2 Progress Bar") # Configure le titre de la fenêtre
self.setGeometry(300, 300, 500,
400) # Configure la taille de la fenêtre
self.setIcon()
# Create Progress Bar
self.statusLabel = QLabel("Showing Progress")
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
self.createStatusBar()
def setIcon(self):
appIcon = QIcon("icon.png")
self.setWindowIcon(appIcon)
def createStatusBar(self):
self.statusBar = QStatusBar()
self.progressBar.setValue(10)
self.statusBar.addWidget(self.statusLabel, 1)
self.statusBar.addWidget(self.progressBar, 2)
self.setStatusBar(self.statusBar)
class MainWindow(QMainWindow):
# Constructor function
def __init__(self):
super(MainWindow, self).__init__()
self.initGUI()
def initGUI(self):
self.setWindowTitle("Main Window")
self.setGeometry(300, 250, 400, 300)
self.statusLabel = QLabel('Showing Progress')
self.CreateProgessBar()
self.CreateStatusBar()
self.show()
def CreateProgessBar(self):
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
def CreateStatusBar(self): # Function to create the status bar
self.myStatusBar = QStatusBar()
#self.progressBar.setValue(0)
self.myStatusBar.addWidget(self.statusLabel, 1)
self.myStatusBar.addWidget(self.progressBar, 2)
self.setStatusBar(self.myStatusBar)
def ShowProgress(self, progress): # Function to show progress
self.progressBar.setValue(progress)
if progress == 100:
self.statusLabel.setText('Ready')
return
class Window(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("sttting icon")
self.setGeometry(300, 300, 500, 400)
self.setIcon()
# showing a hint, or tooltip
self.setToolTip("this is window")
# self.setButton()
self.center()
self.pushButton()
self.statusLabel = QLabel("showing progress")
self.progressbar = QProgressBar()
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
self.createStatusBar()
def setIcon(self):
appIcon = QIcon("Screenshot from 2019-10-15 09-33-25.png")
self.setWindowIcon(appIcon)
def setButton(self):
btn1 = QPushButton("Quit", self)
btn1.move(50,100)
btn1.clicked.connect(self.quitApp)
def quitApp(self):
userInfo = QMessageBox.question(self, "Confirmation", "Do you want to quit the application ?", QMessageBox.Yes|QMessageBox.No)
if(userInfo == QMessageBox.Yes):
myapp.quit()
elif(userInfo == QMessageBox.No):
pass
def center(self):
qRect = self.frameGeometry()
centerPoint = QDesktopWidget().availableGeometry().center()
qRect.moveCenter(centerPoint)
self.move(qRect.topLeft())
def pushButton(self):
self.aboutButton = QPushButton("About box", self)
self.aboutButton.move(50, 100)
# self.move(50, 100)
self.aboutButton.clicked.connect(self.aboutBox)
def aboutBox(self):
QMessageBox.about(self.aboutButton, "About pyside 2", "Pyside 2 is cross platfirmn gui")
def createStatusBar(self):
self.myStatus = QStatusBar()
# self.myStatus.showMessage("status bar is ready", 3000)
self.progressbar.setValue(10)
self.myStatus.addWidget(self.statusLabel, 1)
self.myStatus.addWidget(self.progressbar, 2)
self.setStatusBar(self.myStatus)
def initUI(self):
self.but = QPushButton('スタート')
self.but.clicked.connect(self.task_start)
self.setCentralWidget(self.but)
status_label = QLabel('進捗')
status_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.proggress_bar = QProgressBar()
self.proggress_bar.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
status_bar = QStatusBar()
status_bar.addWidget(status_label, 1)
status_bar.addWidget(self.proggress_bar, 2)
self.setStatusBar(status_bar)
class Window(QMainWindow):
def __init__(self):
super(Window, self).__init__()
self.setWindowTitle("Progress Bar")
self.setGeometry(300, 300, 300, 300)
self.statusLabel = QLabel("showing progress")
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
self.progressBar.setValue(20)
self.createStatusBar()
def createStatusBar(self):
self.statusBar = QStatusBar()
self.statusBar.addWidget(self.statusLabel, 1)
self.statusBar.addWidget(self.progressBar, 2)
self.setStatusBar(self.statusBar)
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle("A Company Login Windows")
self.setGeometry(300,250,400,300)
#self.CreateStatusBar()
self.CreateProgressBar()
#self.showProgress()
def CreateStatusBar(self):
self.myStatusBar = QStatusBar()
self.myStatusBar.showMessage('Ready',0)
self.setStatusBar(self.myStatusBar)
def CreateProgressBar(self):
self.myStatusBar = QStatusBar()
self.progressBar = QProgressBar()
self.statusLabel = QLabel("Showing Progress")
#self.finishLabel = QLabel("Finish Progress")
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
self.progressBar.setValue(0)
self.myStatusBar.addWidget(self.statusLabel,1)
self.myStatusBar.addWidget(self.progressBar,2)
#self.myStatusBar.addWidget(self.finishLabel,3)
self.setStatusBar(self.myStatusBar)
def showProgress(self):
while(self.progressBar.value() < self.progressBar.maximum()):
self.progressBar.setValue(self.progressBar.value() + 10)
time.sleep(1)
self.statusLabel.setText('Ready')
class MainWindow(QMainWindow):
def __init__(self, rtsp_url: str, parent=None):
super().__init__(parent)
self.image_updater = ImageUpdater(rtsp_url, self)
self.status_bar = QStatusBar()
self.setStatusBar(self.status_bar)
self.position_label = QLabel("X: -, Y: -")
self.status_bar.addWidget(self.position_label)
self.central_widget = QWidget()
self.main_grid = QGridLayout()
self.secondary_grid = QGridLayout()
self.main_grid.addLayout(self.secondary_grid, 0, 0)
self.main_image = ImageWidget("Connecting...", 0.7)
self.main_image.mouse_move.connect(
lambda x, y: self.position_label.setText(f"X: {x}, Y: {y}"))
self.main_grid.addWidget(self.main_image, 0, 1)
self.roi_image = QLabel("No image data")
self.secondary_grid.addWidget(self.roi_image, 0, 0)
self.central_widget.setLayout(self.main_grid)
self.setCentralWidget(self.central_widget)
self.resize(1600, 800)
self.setWindowTitle('Parking statistics')
self.show()
self.image_updater.update.connect(self.main_image.update_image,
Qt.QueuedConnection)
self.image_updater.start()
def closeEvent(self, event: QCloseEvent):
self.image_updater.stop()
event.accept()
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
self.setGeometry(300,200,500,100)
self.centralWidget = QtWidgets.QWidget(MainWindow)
self.gridLayout = QtWidgets.QGridLayout(self.centralWidget)
selectVideoLabel = QLabel(self.centralWidget)
selectVideoLabel.setText("Select a video to summarize:")
self.file_Select_Btn = QPushButton(self.centralWidget)
self.file_Select_Btn.setGeometry(QtCore.QRect(1082, 80, 121, 28))
self.file_Select_Btn.setObjectName("file_Select_Btn")
self.file_Select_Btn.setText("Load Video")
self.gridLayout.addWidget(selectVideoLabel)
self.gridLayout.addWidget(self.file_Select_Btn)
MainWindow.setCentralWidget(self.centralWidget)
self.statusLabel = QLabel("Loading Video ...")
self.progressbar = QProgressBar()
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
self.createStatusBar()
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def createStatusBar(self):
self.statusBar = QStatusBar()
self.progressbar.setValue(0)
self.statusBar.addWidget(self.statusLabel, 1)
self.statusBar.addWidget(self.progressbar, 2)
class Main_Window(QMainWindow):
'''Our Main Window Class'''
def __init__(self):
'''Constructure Function'''
QMainWindow.__init__(self)
self.setWindowTitle("A Sample Text Editor")
self.setWindowIcon(QIcon('doc_open.png'))
self.setGeometry(350, 250, 550, 400) # self.setGeometry(x,y,w,h)
#self.setMinimumSize(250,250)# Size -> Width * Height
#self.setMaximumSize(750,750)
self.CreateStatusBar()
#self.CreateProgressBar()
#self.showProgress()
self.setUpComponents()
def setUpComponents(self):
'''Setting Up Central Widget'''
self.textEdit = QTextEdit("Enter your Text Here")
self.setCentralWidget(self.textEdit)
self.CreateActions()
self.CreateMenus()
self.CreateToolBar()
self.fileMenu.addAction(self.newAction)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitAction)
self.fileMenu.addAction(self.copyAction)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.pasteAction)
self.fileMenu.addAction(self.aboutAction)
self.mainToolbar.addAction(self.newAction)
self.mainToolbar.addSeparator()
self.mainToolbar.addAction(self.copyAction)
self.mainToolbar.addAction(self.pasteAction)
def CreateToolBar(self):
'''Function to Create Toolbar'''
self.mainToolbar = self.addToolBar('Main')
#Slots Menu When Menu actions are Triggered
def newFile(self):
self.textEdit.setText('')
def exitFile(self):
self.close()
def aboutHelp(self):
QMessageBox.about(self, "About Simple Text Editor",
"This Example Demonstrate the Use of Menu Bar")
def CreateActions(self):
'''Functions to Create actions for Menus'''
self.newAction = QAction(QIcon('doc_open.png'),
'&New',
self,
shortcut=QKeySequence.New,
statusTip='Create a New File',
triggered=self.newFile)
self.exitAction = QAction(QIcon('doc_open.png'),
'E&xit',
self,
shortcut="Ctrl+Q",
statusTip="Exit the Application",
triggered=self.exitFile)
self.copyAction = QAction(QIcon("doc_open.png"),
'C&opy',
self,
shortcut="Ctrl+c",
statusTip="Copy",
triggered=self.textEdit.copy)
self.pasteAction = QAction(QIcon('paste.png'),
'&Paste',
self,
shortcut="Ctrl+V",
statusTip="Paste",
triggered=self.textEdit.paste)
self.aboutAction = QAction(QIcon('about.png'),
'A&bout',
self,
statusTip="Displays info about text editor",
triggered=self.aboutHelp)
def CreateMenus(self):
#Actual Menu Bar Item Creation
'''Function to Create actual menu bar'''
self.fileMenu = self.menuBar().addMenu("&File")
self.editMenu = self.menuBar().addMenu("&Edit")
self.helpMenu = self.menuBar().addMenu("&Help")
def showProgress(self):
'''Function to Show Progress'''
self.CreateProgressBar()
while (self.progressbar.value() < self.progressbar.maximum()):
self.progressbar.setValue(self.progressbar.value() + 10)
time.sleep(0.5)
self.myProgressMessage.setText("Ready")
def CreateProgressBar(self):
'''Function to Create Progrss Bar'''
self.myProgressMessage = QLabel("In Progress")
self.progressbar = QProgressBar()
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
self.myProgressStatusBar = QStatusBar()
self.progressbar.setValue(0)
self.myProgressStatusBar.addWidget(self.myProgressMessage, 1)
self.myProgressStatusBar.addWidget(self.progressbar, 2)
self.setStatusBar(self.myProgressStatusBar)
def CreateStatusBar(self):
'''Function to Create Status Bar'''
self.myStatusBar = QStatusBar()
self.myStatusBar.showMessage("Getting Ready", 2000)
self.setStatusBar(self.myStatusBar)
class PyFOrg(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
main_widget = QWidget()
self.gui = gui_gen.Ui_MainWidget()
self.gui.setupUi(main_widget)
self.setup_status_bar()
self.setCentralWidget(main_widget)
self.load_config()
self.bind_signals()
self.req_comp_widgets = [
self.gui.comp_threshold_slider,
self.gui.expand_tree,
self.gui.expand_checked_tree_items,
self.gui.check_all_tree_items,
self.gui.collapse_checked_tree_items,
self.gui.collapse_tree,
self.gui.uncheck_all_tree_items,
self.gui.collapse_unchecked_tree_items,
self.gui.expand_unchecked_tree_items,
self.gui.button_check_items,
self.gui.button_move_files,
]
self.enable_comp_widgets(False)
def enable_comp_widgets(self, enable):
for widget in self.req_comp_widgets:
widget.setEnabled(enable)
def setup_status_bar(self):
self.status_bar = QStatusBar()
self.status_label = QLabel(self.status_bar)
self.status_bar.addWidget(self.status_label)
self.setStatusBar(self.status_bar)
self.set_status_text("Idle")
def set_status_text(self, text):
self.status_label.setText(text)
def load_config(self):
self.config = config.ConfigObj()
try:
with open("config.json", "r") as fp:
self.config.load(json.load(fp))
except:
# No config file - Using Defaults
pass
self.gui.comp_threshold_slider.setValue(self.config.comp_threshold)
self.gui.slider_word_length_weighting.setValue(
self.config.word_length_weighting)
self.gui.slider_str_length_difference_weighting.setValue(
self.config.str_length_weighting)
self.gui.slider_word_length_difference_weighting.setValue(
self.config.word_difference_weighting)
self.gui.filename_cleaner_text_ctrl.setText(self.config.strip_str)
self.gui.sort_source_location.setText(self.config.sort_from_dir)
self.gui.sort_into_dir.setText(self.config.sort_to_dir)
self.gui.enable_disable_sort_to.setChecked(
self.config.enable_sort_to_dir)
self.gui.text_clean_parentheses_checkbox.setChecked(
self.config.parentheses)
self.gui.text_clean_brackets_checkbox.setChecked(self.config.brackets)
self.gui.text_clean_curly_brackets_checkbox.setChecked(
self.config.curly_braces)
self.gui.repeated_filename_checkbox.setChecked(
self.config.duplicate_segments)
self.gui.strip_extensions_checkbox.setChecked(
self.config.file_extensions)
self.gui.strip_single_letters_no_i_checkbox.setChecked(
self.config.strip_single_letters_no_i)
self.gui.strip_single_letters_including_i_checkbox.setChecked(
self.config.strip_single_letters_including_i)
self.gui.strip_vol_chapter_strings_checkbox.setChecked(
self.config.strip_vol_chapter_strings)
self.gui.strip_digits_checkbox.setChecked(self.config.strip_digits)
# Update the labels
self.handler_threshold_slider_adjusted(None)
self.handler_word_length_weighting_adjusted(None)
self.handler_str_len_difference_adjusted(None)
self.handler_word_len_difference_weighting_adjusted(None)
def bind_signals(self):
self.gui.slider_word_length_weighting.valueChanged.connect(
self.handler_word_length_weighting_adjusted)
self.gui.slider_str_length_difference_weighting.valueChanged.connect(
self.handler_str_len_difference_adjusted)
self.gui.slider_word_length_difference_weighting.valueChanged.connect(
self.handler_word_len_difference_weighting_adjusted)
self.gui.slider_num_file_for_checking.valueChanged.connect(
self.handler_check_slider_changed)
self.gui.text_clean_parentheses_checkbox.stateChanged.connect(
self.handler_update_checkboxes_config)
self.gui.text_clean_brackets_checkbox.stateChanged.connect(
self.handler_update_checkboxes_config)
self.gui.text_clean_curly_brackets_checkbox.stateChanged.connect(
self.handler_update_checkboxes_config)
self.gui.repeated_filename_checkbox.stateChanged.connect(
self.handler_update_checkboxes_config)
self.gui.strip_extensions_checkbox.stateChanged.connect(
self.handler_update_checkboxes_config)
self.gui.strip_single_letters_no_i_checkbox.stateChanged.connect(
self.handler_update_checkboxes_config)
self.gui.strip_single_letters_including_i_checkbox.stateChanged.connect(
self.handler_update_checkboxes_config)
self.gui.strip_vol_chapter_strings_checkbox.stateChanged.connect(
self.handler_update_checkboxes_config)
self.gui.strip_digits_checkbox.stateChanged.connect(
self.handler_update_checkboxes_config)
self.gui.filename_cleaner_text_ctrl.editingFinished.connect(
self.handler_text_entry_fields)
self.gui.sort_source_location.editingFinished.connect(
self.handler_text_entry_fields)
self.gui.sort_into_dir.editingFinished.connect(
self.handler_text_entry_fields)
self.gui.expand_tree.clicked.connect(self.handler_expand_tree)
self.gui.expand_checked_tree_items.clicked.connect(
self.handler_expand_checked_tree_items)
self.gui.check_all_tree_items.clicked.connect(
self.handler_check_all_tree_items)
self.gui.collapse_checked_tree_items.clicked.connect(
self.handler_collapse_checked_tree_items)
self.gui.collapse_tree.clicked.connect(self.handler_collapse_tree)
self.gui.uncheck_all_tree_items.clicked.connect(
self.handler_uncheck_all_tree_items)
self.gui.collapse_unchecked_tree_items.clicked.connect(
self.handler_collapse_unchecked_tree_items)
self.gui.expand_unchecked_tree_items.clicked.connect(
self.handler_expand_unchecked_tree_items)
self.gui.button_check_items.clicked.connect(
self.handler_check_items_with_threshold)
self.gui.button_move_files.clicked.connect(
self.handler_move_selected_items_into_new_folders)
self.gui.start_proc_button.clicked.connect(
self.handler_start_dir_processing)
self.gui.select_dir_button.clicked.connect(
self.handler_select_source_dir_pressed)
self.gui.select_sort_into_dir_button.clicked.connect(
self.handler_select_target_dir_pressed)
self.handler_toggle_sort_to_evt(None)
self.gui.enable_disable_sort_to.toggled.connect(
self.handler_toggle_sort_to_evt)
self.gui.comp_threshold_slider.valueChanged.connect(
self.handler_threshold_slider_adjusted)
self.gui.comp_threshold_slider.sliderReleased.connect(
self.handler_threshold_slider_changed)
def handler_select_source_dir_pressed(self, _event):
new_folder = QFileDialog.getExistingDirectory(
self,
caption='Select source directory to sort',
dir=self.config.sort_from_dir)
if new_folder:
self.gui.sort_source_location.setText(new_folder)
self.config.sort_from_dir = new_folder
def handler_select_target_dir_pressed(self, _event):
new_folder = QFileDialog.getExistingDirectory(
self,
caption='Select target directory to sort into',
dir=self.config.sort_to_dir)
if new_folder:
self.gui.sort_into_dir.setText(new_folder)
self.config.sort_to_dir = new_folder
def handler_toggle_sort_to_evt(self, _event):
self.config.enable_sort_to_dir = self.gui.enable_disable_sort_to.isChecked(
)
if not self.config.enable_sort_to_dir:
self.gui.sort_into_dir.setEnabled(False)
self.gui.select_sort_into_dir_button.setEnabled(False)
self.gui.enable_disable_sort_to.setText("Enable")
else:
self.gui.sort_into_dir.setEnabled(True)
self.gui.select_sort_into_dir_button.setEnabled(True)
self.gui.enable_disable_sort_to.setText("Disable")
def handler_word_length_weighting_adjusted(self, _event):
self.config.word_length_weighting = float(
self.gui.slider_word_length_weighting.value())
textVal = self.config.word_length_weighting / 1000
self.gui.value_word_length_weighting.setText("%0.3f" % textVal)
def handler_str_len_difference_adjusted(self, _event):
self.config.str_length_weighting = float(
self.gui.slider_str_length_difference_weighting.value())
textVal = self.config.str_length_weighting / 1000
self.gui.value_str_length_difference_weighting.setText("%0.3f" %
textVal)
def handler_word_len_difference_weighting_adjusted(self, _event):
self.config.word_difference_weighting = float(
self.gui.slider_word_length_difference_weighting.value())
textVal = self.config.word_difference_weighting / 1000
self.gui.value_word_length_difference_weighting.setText("%0.3f" %
textVal)
def handler_threshold_slider_adjusted(self, _event):
self.config.comp_threshold = self.gui.comp_threshold_slider.value()
self.gui.com_threshold_slider_value_label.setText(
"%0.3f" % self.config.getCompThresh())
def handler_check_slider_changed(self, _event):
val = self.gui.slider_num_file_for_checking.value()
self.gui.slider_num_file_for_checking_label.setText("%s" % val)
def handler_update_checkboxes_config(self, _event):
self.config.parentheses = self.gui.text_clean_parentheses_checkbox.isChecked(
)
self.config.brackets = self.gui.text_clean_brackets_checkbox.isChecked(
)
self.config.curly_braces = self.gui.text_clean_curly_brackets_checkbox.isChecked(
)
self.config.duplicate_segments = self.gui.repeated_filename_checkbox.isChecked(
)
self.config.file_extensions = self.gui.strip_extensions_checkbox.isChecked(
)
self.config.strip_single_letters_no_i = self.gui.strip_single_letters_no_i_checkbox.isChecked(
)
self.config.strip_single_letters_including_i = self.gui.strip_single_letters_including_i_checkbox.isChecked(
)
self.config.strip_vol_chapter_strings = self.gui.strip_vol_chapter_strings_checkbox.isChecked(
)
self.config.strip_digits = self.gui.strip_digits_checkbox.isChecked()
def handler_threshold_slider_changed(self):
try:
assert self.compar
self.set_status_text("Recomputing similarity tree")
trimmed_dict = self.compar.trimTree(self.config.getCompThresh())
self.set_status_text("Trimmed tree contains %s items" %
(len(trimmed_dict), ))
#print "Adding Tree"
#print trimmed_dict
self.add_dict_to_tree(trimmed_dict)
except:
traceback.print_stack()
self.set_status_text("Need to run comparison first")
def handler_text_entry_fields(self):
self.config.strip_str = self.gui.filename_cleaner_text_ctrl.text()
self.config.sort_from_dir = self.gui.sort_source_location.text()
self.config.sort_to_dir = self.gui.sort_into_dir.text()
def closeEvent(self, _event):
self.set_status_text("Exiting")
try:
self.compar.close()
except:
pass
with open("config.json", "w") as fp:
conf = json.dumps(self.config.dump(), indent=4)
fp.write(conf)
def handler_start_dir_processing(self, _event):
terms = self.gui.filename_cleaner_text_ctrl.text().split(":")
terms = [tmp for tmp in terms if tmp]
self.config.strip_terms = terms
if self.config.enable_sort_to_dir and not os.access(
self.config.sort_to_dir, os.F_OK):
msg_box = QMessageBox()
msg_box.setText("Cannot Access Path %s" % self.config.sort_to_dir)
msg_box.exec_()
return
if not os.access(self.config.sort_from_dir, os.F_OK):
msg_box = QMessageBox()
msg_box.setText("Cannot Access Path %s" %
self.config.sort_from_dir)
msg_box.exec_()
return
self.compar = file_comparator.Comparator(self.config)
if self.config.enable_sort_to_dir:
self.compar.sort_into(self.config.sort_from_dir,
self.config.sort_to_dir)
else:
self.compar.sort(self.config.sort_from_dir)
self.set_status_text("Sort Complete")
trimmed_dict = self.compar.trimTree(self.config.getCompThresh())
#print trimmed_dict
if len(trimmed_dict) < 1:
self.set_status_text(
"No items. Either folder is empty or thresholds are set incorrectly."
)
else:
self.set_status_text("Trimmed tree contains %s items" %
(len(trimmed_dict), ))
self.add_dict_to_tree(trimmed_dict)
self.enable_comp_widgets(True)
def handler_check_items_with_threshold(self, _event):
slider_val = self.gui.slider_num_file_for_checking.value()
for idx in range(self.gui.file_tree.topLevelItemCount()):
item = self.gui.file_tree.topLevelItem(idx)
child_cnt = item.childCount()
if child_cnt >= slider_val:
item.setCheckState(0, Qt.Checked)
else:
item.setCheckState(0, Qt.Unchecked)
def handler_expand_tree(self, _event):
self.gui.file_tree.expandAll()
def handler_collapse_tree(self, _event):
self.gui.file_tree.collapseAll()
def handler_check_all_tree_items(self, _event):
for idx in range(self.gui.file_tree.topLevelItemCount()):
item = self.gui.file_tree.topLevelItem(idx)
item.setCheckState(0, Qt.Checked)
def handler_uncheck_all_tree_items(self, _event):
for idx in range(self.gui.file_tree.topLevelItemCount()):
item = self.gui.file_tree.topLevelItem(idx)
item.setCheckState(0, Qt.Unchecked)
def handler_collapse_checked_tree_items(self, _event):
for idx in range(self.gui.file_tree.topLevelItemCount()):
item = self.gui.file_tree.topLevelItem(idx)
checked = item.checkState(0)
if checked in [Qt.Checked, Qt.PartiallyChecked]:
item.setExpanded(False)
def handler_expand_checked_tree_items(self, _event):
for idx in range(self.gui.file_tree.topLevelItemCount()):
item = self.gui.file_tree.topLevelItem(idx)
checked = item.checkState(0)
if checked in [Qt.Checked, Qt.PartiallyChecked]:
item.setExpanded(True)
def handler_collapse_unchecked_tree_items(self, _event):
for idx in range(self.gui.file_tree.topLevelItemCount()):
item = self.gui.file_tree.topLevelItem(idx)
checked = item.checkState(0)
if checked == Qt.Unchecked:
item.setExpanded(False)
def handler_expand_unchecked_tree_items(self, _event):
for idx in range(self.gui.file_tree.topLevelItemCount()):
item = self.gui.file_tree.topLevelItem(idx)
checked = item.checkState(0)
if checked == Qt.Unchecked:
item.setExpanded(True)
def add_dict_to_tree(self, filesList):
self.gui.file_tree.clear()
for group in filesList:
parent = QTreeWidgetItem(self.gui.file_tree)
parent.setFlags(parent.flags() | Qt.ItemIsTristate
| Qt.ItemIsUserCheckable)
source_item = None
for item_object, simVal in group.items():
if simVal == "Source":
parent.setText(0, "{}".format(item_object.fn))
parent.setText(3, "{}".format(item_object.src_fqpath))
source_item = item_object
assert source_item is not None
for item_object, simVal in group.items():
if simVal == "Source":
continue
branch = QTreeWidgetItem(parent)
branch.setFlags(branch.flags() | Qt.ItemIsUserCheckable)
branch.setText(CLEANED_NAME_COLUMN, item_object.cn)
branch.setText(FILE_NAME_COLUMN, item_object.fn)
branch.setText(SOURCE_FQPATH_COLUMN,
"%s" % (item_object.src_fqpath, ))
branch.setText(DEST_FQPATH_COLUMN,
"%s" % (item_object.dest_fqpath, ))
if isinstance(simVal, (int, float)):
branch.setText(SIMILARITY_COLUMN, "%0.5f" % (simVal, ))
else:
branch.setText(SIMILARITY_COLUMN, "%s" % (simVal, ))
branch.setCheckState(0, Qt.Unchecked)
branch.item_data = item_object
self.gui.file_tree.setColumnWidth(CLEANED_NAME_COLUMN, 400)
self.gui.file_tree.setColumnWidth(FILE_NAME_COLUMN, 400)
self.gui.file_tree.setColumnWidth(SOURCE_FQPATH_COLUMN, 100)
self.gui.file_tree.setColumnWidth(DEST_FQPATH_COLUMN, 100)
self.gui.file_tree.setColumnWidth(SIMILARITY_COLUMN, 100)
def handler_move_selected_items_into_new_folders(self, _event):
if self.config.enable_sort_to_dir:
output_folder = self.config.sort_to_dir
else:
output_folder = QFileDialog.getExistingDirectory(
self,
caption='Select directory to create new folders in',
dir=self.config.last_move_to_dir,
)
if not output_folder:
msg_box = QMessageBox()
msg_box.setText("No output folder! How did this happen?")
msg_box.exec_()
return
self.config.last_move_to_dir = output_folder
self.set_status_text("Item count: %s" %
self.gui.file_tree.topLevelItemCount())
moved = 0
errors = 0
already_existing = 0
for root_idx in range(self.gui.file_tree.topLevelItemCount()):
item = self.gui.file_tree.topLevelItem(root_idx)
child_cnt = item.childCount()
checked = item.checkState(0)
if checked in [Qt.Checked, Qt.PartiallyChecked]:
# Don't create directories if we're in sort-into mode.
if not self.config.enable_sort_to_dir:
# Column 0 is the header column
first_child = item.child(0)
item_folder_name = os.path.join(
output_folder,
first_child.item_data.cleared_name.title())
if not os.access(item_folder_name, os.F_OK):
os.mkdir(item_folder_name)
for child_idx in range(child_cnt):
child = item.child(child_idx)
child.item_data.set_dest_path(item_folder_name)
for child_idx in range(child_cnt):
child = item.child(child_idx)
child_checked = child.checkState(0)
if child_checked == Qt.Checked:
source_fn = child.item_data.src_fqpath
dest_fn = child.item_data.dest_fqpath
if os.access(dest_fn, os.F_OK):
already_existing += 1
self.set_status_text(
"Destination file %s already exists!" %
(dest_fn, ))
elif os.access(source_fn, os.F_OK):
shutil.move(source_fn, dest_fn)
moved += 1
else:
errors += 1
self.set_status_text(
"Cannot access source file %s!" %
(source_fn, ))
self.set_status_text(
"Moved %s files, encountered %s errors and skipped moving %s files as they already exist."
% (moved, errors, already_existing))
class MainWindow(QWidget):
def __init__(self):
super().__init__()
self.signals = Signals()
self.initUI()
self.setSignals()
self.decensor = Decensor(self)
self.load_model()
def initUI(self):
grid_layout = QGridLayout()
grid_layout.setSpacing(10)
self.setLayout(grid_layout)
#Tutorial
self.tutorialLabel = QLabel()
self.tutorialLabel.setText(
"Welcome to DeepCreamPy!\n\nIf you're new to DCP, please read the README.\nThis program does nothing without the proper setup of your images.\n\nReport any bugs you encounter to me on Github or Twitter @deeppomf."
)
self.tutorialLabel.setAlignment(Qt.AlignCenter)
self.tutorialLabel.setFont(QFont('Sans Serif', 13))
#Censor type group
self.censorTypeGroupBox = QGroupBox('Censor Type')
barButton = QRadioButton('Bar censor')
mosaicButton = QRadioButton('Mosaic censor')
barButton.setChecked(True)
censorLayout = QVBoxLayout()
censorLayout.addWidget(barButton)
censorLayout.addWidget(mosaicButton)
# censorLayout.addStretch(1)
self.censorTypeGroupBox.setLayout(censorLayout)
#Variation count group
self.variationsGroupBox = QGroupBox('Number of Decensor Variations')
var1Button = QRadioButton('1')
var2Button = QRadioButton('2')
var3Button = QRadioButton('4')
var1Button.setChecked(True)
varLayout = QVBoxLayout()
varLayout.addWidget(var1Button)
varLayout.addWidget(var2Button)
varLayout.addWidget(var3Button)
# varLayout.addStretch(1)
self.variationsGroupBox.setLayout(varLayout)
#Decensor button
self.decensorButton = QPushButton('Decensor Your Images')
self.decensorButton.clicked.connect(self.decensorClicked)
self.decensorButton.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
#Progress message
# self.progressGroupBox = QGroupBox('Progress')
self.progressMessage = QTextEdit()
self.progressCursor = QTextCursor(self.progressMessage.document())
self.progressMessage.setTextCursor(self.progressCursor)
self.progressMessage.setReadOnly(True)
self.progressCursor.insertText(
"After you prepared your images, click on the decensor button once to begin decensoring.\nPlease be patient.\nDecensoring will take time.\n"
)
# Progress Bar
self.statusBar = QStatusBar(self)
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
self.progressBar.setValue(0)
self.statusLabel = QLabel("Showing Progress")
self.statusBar.addWidget(self.statusLabel, 1)
self.statusBar.addWidget(self.progressBar, 2)
#put all groups into grid
# addWidget(row, column, rowSpan, columnSpan)
grid_layout.addWidget(self.tutorialLabel, 0, 0, 1, 2)
grid_layout.addWidget(self.censorTypeGroupBox, 1, 0, 1, 1)
grid_layout.addWidget(self.variationsGroupBox, 1, 1, 1, 1)
grid_layout.addWidget(self.decensorButton, 2, 0, 1, 2)
grid_layout.addWidget(self.progressMessage, 3, 0, 1, 2)
grid_layout.addWidget(self.statusBar, 4, 0, 1, 2)
#window size settings
self.resize(900, 600)
self.center()
self.setWindowTitle('DeepCreamPy v2.2.0-beta')
self.show()
def load_model(self):
# load model to make able to decensor several times
self.decensorButton.setEnabled(False)
self.decensorButton.setText(
"Loading Machine Learning Model (Please Wait...)")
self.decensor.start()
self.decensor.signals = self.signals
self.progressCursor.insertText(
"Loading Decensor app consumes 6 GB memory at maximum")
def setSignals(self):
self.signals.update_decensorButton_Text.connect(
self.decensorButton.setText)
self.signals.update_decensorButton_Enabled.connect(
self.decensorButton.setEnabled)
self.signals.update_statusLabel_Text.connect(self.statusLabel.setText)
self.signals.update_ProgressBar_SET_VALUE.connect(
self.progressBar.setValue)
self.signals.update_ProgressBar_MAX_VALUE.connect(
self.progressBar.setMaximum)
self.signals.update_ProgressBar_MIN_VALUE.connect(
self.progressBar.setMinimum)
# self.signals.insertText_progressCursor.connect(self.progressCursor.insertText)
self.signals.insertText_progressCursor.connect(
self.progressMessage.append)
self.signals.clear_progressMessage.connect(self.progressMessage.clear)
self.signals.appendText_progressMessage.connect(
self.progressMessage.append)
def decensorClicked(self):
self.decensorButton.setEnabled(False)
self.progressMessage.clear()
self.progressCursor.insertText("Decensoring has begun!\n")
# for now, decensor is initiated when this app is started
# self.decensor = Decensor(text_edit = self.progressMessage, text_cursor = self.progressCursor, ui_mode = True)
#https://stackoverflow.com/questions/42349470/pyqt-find-checked-radiobutton-in-a-group
#set decensor to right settings
#censor type
censorTypeElements = self.censorTypeGroupBox.children()
censorButtons = [
elem for elem in censorTypeElements
if isinstance(elem, QRadioButton)
]
for cb in censorButtons:
if cb.isChecked():
censorType = cb.text()
if censorType == 'Bar censor':
self.decensor.is_mosaic = False
else:
self.decensor.is_mosaic = True
#variations count
variationsElements = self.variationsGroupBox.children()
variationsButtons = [
elem for elem in variationsElements
if isinstance(elem, QRadioButton)
]
for vb in variationsButtons:
if vb.isChecked():
variations = int(vb.text())
self.decensor.variations = variations
self.decensorButton.setEnabled(False)
self.decensor.start()
# decensor.decensor_all_images_in_folder()
# #centers the main window
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
class MainWindow(QMainWindow):
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
layout = QHBoxLayout()
# video player object
self.video_player = VideoPlayer(self)
# Tracks table
self.tracks_table = QTableView()
# Keeps display options
self.display_options = {"show_tracks": True,
"show_traces": True,
"show_labels": True}
layout.addWidget(self.video_player)
layout.addWidget(self.tracks_table)
# Create tracks model and items to show in tracks table.
self.tracks_model = QStandardItemModel()
self.tracks_model.setHorizontalHeaderLabels(["Id", "State", "Age"])
self.tracks_table.setModel(self.tracks_model)
self.track_items = {}
widget = QWidget()
widget.setLayout(layout)
self.setCentralWidget(widget)
self.setMinimumHeight(800)
self.setMinimumWidth(1000)
self.tracks_table.setFixedWidth(300)
toolbar = QToolBar("Main")
self.addToolBar(toolbar)
open_button = QAction(self.style().standardIcon(QStyle.SP_DirOpenIcon), "Open Video File", self)
open_button.setStatusTip("Open Video File")
open_button.triggered.connect(self.video_player.open_video_file)
toolbar.addAction(open_button)
toolbar.addWidget(QLabel("Tracks"))
self.tracks_check_box = QCheckBox()
self.tracks_check_box.toggle()
self.tracks_check_box.stateChanged.connect(self.tracks)
toolbar.addWidget(self.tracks_check_box)
toolbar.addWidget(QLabel("Traces"))
self.traces_check_box = QCheckBox()
self.traces_check_box.toggle()
self.traces_check_box.stateChanged.connect(self.traces)
toolbar.addWidget(self.traces_check_box)
toolbar.addWidget(QLabel("Labels"))
self.labels_check_box = QCheckBox()
self.labels_check_box.toggle()
self.labels_check_box.stateChanged.connect(self.labels)
toolbar.addWidget(self.labels_check_box)
self.status_bar = QStatusBar()
self.vps_server_label = QLabel("")
self.tps_server_label = QLabel("")
self.status_bar.addWidget(self.vps_server_label)
self.status_bar.addWidget(self.tps_server_label)
self.setStatusBar(self.status_bar)
def get_or_create_track_row(self, track: dict) -> ():
"""
Get or create a track row in tracks table
Args:
track: Track label and trace
"""
track_id = track[0]
if track_id not in self.track_items:
self.track_items[track_id] = self.add_track_row(track)
return self.track_items[track_id]
def add_track_row(self, track):
"""
Adds a track row to the tracks table model.
Args:
track: Track label and trace
Returns:
id_item
status_item
age_item
"""
id_item = QStandardItem()
id_item.setText(track[0])
id_item.setBackground(QBrush(QColor(
get_random_color(int(track[0]))
)))
id_item.setEditable(False)
status_item = QStandardItem()
status_item.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
status_item.setEditable(False)
age_item = QStandardItem()
age_item.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
age_item.setEditable(False)
self.tracks_model.appendRow([id_item, status_item, age_item])
self.tracks_model.sort(0)
return id_item, status_item, age_item
def update_track_row(self, track_id, trace):
"""
Updates track list and model
Args:
track_id
trace
"""
status = "Active"
if track_id in self.track_items:
# If length of the track trace is not changed
# Track is passive
if len(self.track_items[track_id]) == len(trace):
status = "Passive"
track_id, track_status, track_age = self.get_or_create_track_row(track_id)
track_status.setText(status)
track_age.setText(f"{len(trace)//24}")
def reset_tracks_table(self):
"""Reset tracks_model and track_items"""
self.tracks_model.removeRows(0, len(self.track_items))
self.track_items = {}
def update_server_stats(self, vps_stats_summary, tps_stats_summary):
"""
Updates server statistics.
Args:
vps_stats_summary: Video Processing Server statistics
tps_stats_summary: Track Processing Server statistics
"""
self.tps_server_label.setText(tps_stats_summary)
self.vps_server_label.setText(vps_stats_summary)
def update_track_viewer(self, tracks):
"""
Update tracks table
Args:
tracks
"""
if not tracks: # Skip update if we have no data.
return
for track_id, trace in tracks.items():
self.update_track_row(track_id, trace)
def traces(self):
"""Changes trace display options."""
self.display_options["show_traces"] = not self.display_options["show_traces"]
def labels(self):
"""Changes labels display options."""
self.display_options["show_labels"] = not self.display_options["show_labels"]
def tracks(self):
"""Changes tracks display options."""
self.display_options["show_tracks"] = not self.display_options["show_tracks"]
def closeEvent(self, event):
"""Exit application."""
reply = QMessageBox.question(self, 'Window Close', 'Are you sure you want to close the window?',
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.video_player.close()
event.accept()
else:
event.ignore()
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super().__init__(parent)
# Setting a Central Widget
self.timer_widget = TimerWidget(parent=self)
self.setCentralWidget(self.timer_widget)
self.setWindowTitle("Timesheet")
# Set up a menubar
menu_bar = self.menuBar()
# Set up the File Menu
file_menu = menu_bar.addMenu("File")
open_action = QAction("Open", self)
close_action = QAction("Close", self)
save_action = QAction("Save", self)
clear_action = QAction("Clear", self)
file_menu.addAction(open_action)
file_menu.addAction(close_action)
file_menu.addAction(save_action)
file_menu.addAction(clear_action)
# Set up the Edit Menu
edit_menu = menu_bar.addMenu("Edit")
client_action = QAction("View Clients", self)
viewer_action = QAction("Current Timesheet", self)
export_action = QAction("Weekly Timesheet", self)
manual_action = QAction("Manual Change", self)
edit_menu.addAction(client_action)
edit_menu.addAction(viewer_action)
edit_menu.addAction(export_action)
edit_menu.addAction(manual_action)
# Connect the buttons
save_action.triggered.connect(self.timer_widget.save_time)
clear_action.triggered.connect(self.clear_timesheet)
close_action.triggered.connect(self.close)
client_action.triggered.connect(self.show_client_list)
viewer_action.triggered.connect(self.show_current_timesheet)
export_action.triggered.connect(self.show_viewer)
manual_action.triggered.connect(self.show_manual)
# Set up the statusbar
self.status_bar = QStatusBar()
self.status_bar.addWidget(self.timer_widget.status_label)
self.setStatusBar(self.status_bar)
def show_client_list(self):
self.dialog = ClientList(parent=self)
self.dialog.setModal(True)
self.dialog.show()
def clear_timesheet(self, event):
if ct.current_timesheet:
ret = self.close_menu_dialog(
set_text="Clear Timesheet Entries!",
set_info_text="This will delete all timesheet entries for today. Are you sure?",
)
if ret == QMessageBox.No:
return
else:
ct.current_timesheet = defaultdict(float)
return
def show_current_timesheet(self):
self.dialog = CurrentTimesheetViewer(parent=self)
self.dialog.setModal(True)
self.dialog.show()
def show_viewer(self):
self.dialog = Viewer(parent=self)
self.dialog.setModal(True)
self.dialog.show()
def show_manual(self):
self.dialog = ChangeTimeWidget(parent=self)
self.dialog.setModal(True)
self.dialog.show()
def closeEvent(self, event):
if self.timer_widget.is_running:
ret = self.close_menu_dialog(
set_text="Your Timesheet is still running!",
set_info_text="Are you sure you want to exit?",
)
if ret == QMessageBox.No:
event.ignore()
return
if ct.current_timesheet:
ret = self.close_menu_dialog(
set_text="You have not saved your Timesheet!",
set_info_text="Are you sure you want to exit?",
)
if ret == QMessageBox.No:
event.ignore()
return
self.timer_widget.delete_autosave()
event.accept()
def close_menu_dialog(self, set_text, set_info_text):
msg_box = QMessageBox(self)
msg_box.setWindowTitle("Exit Warning")
msg_box.setText(set_text)
msg_box.setInformativeText(set_info_text)
msg_box.setIcon(QMessageBox.Critical)
msg_box.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msg_box.setDefaultButton(QMessageBox.No)
ret = msg_box.exec_()
return ret
class App(QMainWindow):
# ------------------------------------------
# -- Initialize the Class
# ------------------------------------------
def __init__(self):
super(App, self).__init__()
# -- Home Directory
self.home_path = expanduser("~")
# -- Base Path
# self.app_path = os.path.abspath(__file__)
self.app_path = sys.argv[0]
self.base_path_split = self.app_path.split('/')
self.base_path = str('/').join(self.base_path_split[0:-1])
# -- Files under config
self.config_file = self.base_path + '/config/config.json'
self.connect_file = self.base_path + '/config/connect.sh'
self.table_file = self.base_path + '/config/table.csv'
self.delimiter_table_row = ';'
# -- Data of Config File (with Default Values)
self.config_data_file = {
'Message': {
'FileReadSuccess': True,
'FileReadFailed': True,
'ColorRedefinition': True
},
'Window': {
'Left': 100,
'Top': 100,
'Width': 640,
'Height': 480
},
'Margin': {
'Left': 11,
'Top': 11,
'Right': 11,
'Bottom': 11
},
'Title': {
'Label': 'SLT - Simple Login Tool - ' + __version__
},
'Button': {
'Connect': {
'Label': 'Connect'
},
'Message': {
'Label': 'X'
}
},
'Table': {
'Header': [],
'Column': {
'Color':
1, # -- Number of column which used for text matching
'Connect': [
9, 1
] # -- These are those column numbers which data picked from the selected row and will be used as connection parameters
},
'Cell': {
'Color': {}
}
}
}
# -- Data of Table File
self.table_data_file = []
# -- Dictionary of Colors with QColor Elements
self.color_data = {}
# -- Central Widget
self.central_widget = None
# -- Main Layout
self.main_layout = None
# -- Input Box
self.input_box = None
# -- Connect Button
self.connect_button = None
# -- Message Button
self.message_button = None
# -- Message Label
self.message_label = None
self.message_label_count = None
# -- Message List
self.message_list = []
# -- Main Table
self.main_table = None
# -- Status Bar
self.status_bar = None
# -- Messages
self.messages = {
'FileReadSuccess': 'INFO: File is opened for read: ',
'FileReadFailed': 'ERROR: File could not be opened for read: ',
'ColorRedefinition': 'WARN: Color Redefinition: '
}
# -- Initialize the UI
self.initUI()
# ------------------------------------------
# -- Create Main Window
# ------------------------------------------
# def createMainWindow(self):
# if (self.main_window is None):
# self.main_window = QMainWindow(self)
# ------------------------------------------
# -- Create Central Widget
# ------------------------------------------
def createCentralWidget(self):
if (self.central_widget is None):
self.central_widget = QWidget()
# -- Set Central Widget for QMainWindow
self.setCentralWidget(self.central_widget)
# ------------------------------------------
# -- Create Layout
# ------------------------------------------
def createLayout(self):
if (self.main_layout is None):
self.main_layout = QGridLayout()
# ------------------------------------------
# -- Create Input Box
# ------------------------------------------
def createInputBox(self):
if (self.input_box is None):
self.input_box = QLineEdit()
# -- Enable Clear Button
self.input_box.setClearButtonEnabled(True)
# -- Create Event if enter pressed
# self.input_box.editingFinished.connect(self.eventSearchInTable)
self.input_box.editingFinished.connect(self.eventConnectButtonClicked)
# -- Create Event if text changed
self.input_box.textChanged.connect(self.eventSearchInTable)
# ------------------------------------------
# -- Search Event
# ------------------------------------------
def eventSearchInTable(self):
# print('Search Event. Look up text is: %s' %(self.input_box.text())) # -- Debug
self.refreshTable(self.input_box.text().strip())
# ------------------------------------------
# -- Create Connect Button
# ------------------------------------------
def createConnectButton(self, text):
if (self.connect_button is None):
self.connect_button = QPushButton(text)
# -- Add Clicked Event
self.connect_button.clicked.connect(self.eventConnectButtonClicked)
# ------------------------------------------
# -- Event for Connect Button Clicked
# ------------------------------------------
def eventConnectButtonClicked(self):
connectParameters = ''
row = 0
# print('Connect Button Pressed') # -- Debug
if (self.main_table.rowCount() == 1):
for column in self.config_data_file['Table']['Column']['Connect']:
cellTable = self.main_table.item(row, column)
connectParameters += ' ' + str(cellTable.text())
self.connectExecute(connectParameters)
# else:
# print('More than one item in table, therefore cannot decide which one to choose') # -- Debug
# ------------------------------------------
# -- Create Status Bar
# ------------------------------------------
def createStatusBar(self):
if (self.status_bar is None):
self.status_bar = QStatusBar()
self.status_bar.addWidget(self.message_label_count, 0)
self.status_bar.addWidget(VLine(), 0)
self.status_bar.addWidget(self.message_label, 1)
self.status_bar.addWidget(self.message_button, 0)
# ------------------------------------------
# -- Update Status Bar
# ------------------------------------------
def updateStatusBar(self):
if (self.status_bar is not None):
# -- Hide the Status Bar if the Message List is empty
if (len(self.message_list) > 0):
self.status_bar.show()
else:
self.status_bar.hide()
# ------------------------------------------
# -- Get Latest Message
# ------------------------------------------
def getLatestMessage(self):
result = None
length = len(self.message_list)
if (length > 0):
result = self.message_list[length - 1]
return result
# ------------------------------------------
# -- Create Message Label
# ------------------------------------------
def createMessageLabel(self):
if (self.message_label is None):
self.message_label = QLabel(self)
# -- Add a Text to Message Label
# self.message_label.setText(self.getLatestMessage())
self.updateMessageLabel()
# ------------------------------------------
# -- Update Message Label with Latest Entry
# ------------------------------------------
def updateMessageLabel(self):
message = ''
length = len(self.message_list)
if (self.message_label is not None):
if (length > 0):
message = self.message_list[-1]
self.message_label.setText(message)
# ------------------------------------------
# -- Create Message Label Count
# ------------------------------------------
def createMessageLabelCount(self):
if (self.message_label_count is None):
self.message_label_count = QLabel(self)
self.updateMessageLabelCount()
# ------------------------------------------
# -- Update Message Label Count
# ------------------------------------------
def updateMessageLabelCount(self):
message = ''
length = len(self.message_list)
if (self.message_label_count is not None):
if (length > 0):
message = ' ' + str(length)
self.message_label_count.setText(message)
# ------------------------------------------
# -- Create Message Button
# ------------------------------------------
def createMessageButton(self, text):
if (self.message_button is None):
self.message_button = QPushButton(text)
# -- Add Clicked Event
self.message_button.clicked.connect(self.eventMessageButtonClicked)
# ------------------------------------------
# -- Event for Message Button Clicked
# ------------------------------------------
def eventMessageButtonClicked(self):
length = len(self.message_list)
# -- Remove the latest item in Message List
if (length > 0):
del self.message_list[length - 1]
# -- Update Message Labels
self.updateMessageLabel()
self.updateMessageLabelCount()
# -- Update the Status Bar
self.updateStatusBar()
# ------------------------------------------
# -- Add a New Message to List
# ------------------------------------------
def addNewMessage(self, message):
self.message_list.append(message)
self.updateMessageLabel()
# -- Update Status Bar
self.updateStatusBar()
# ------------------------------------------
# -- Check Table Header
# ------------------------------------------
def checkMainTableHeader(self, hostsList):
# -- Length of the Header defined in the config file
lengthHeaderconfig_file = len(self.config_data_file['Table']['Header'])
# -- Length of the First Record
if (len(hostsList) > 0):
lengthFirstRecord = len(hostsList[0])
else:
lengthFirstRecord = 0
# -- Append the Header if the list in config file is too short
if (lengthHeaderconfig_file < lengthFirstRecord):
for header in range(lengthHeaderconfig_file + 1,
lengthFirstRecord + 1):
self.config_data_file['Table']['Header'].append(str(header))
# ------------------------------------------
# -- Create Table
# ------------------------------------------
def createMainTable(self, hostsList):
numCell = 0
maxTableRow = len(hostsList)
maxTableColumn = len(self.config_data_file['Table']['Header'])
if (self.main_table is None):
self.main_table = QTableWidget()
# -- Set the Maximum Size of Table
self.main_table.setColumnCount(maxTableColumn)
self.main_table.setRowCount(maxTableRow)
# -- Create the Horizontal Header of Table
headerTableWidget = self.main_table.horizontalHeader()
# -- Set the Table Header
self.main_table.setHorizontalHeaderLabels(
self.config_data_file['Table']['Header'])
# -- Hide The Horizontal Table Header
# self.main_table.horizontalHeader().setVisible(False)
# -- Set the Cells to Read Only
self.main_table.setEditTriggers(QTableWidget.NoEditTriggers)
# -- Set Table Header Properties
for numCell in range(0, len(self.config_data_file['Table']['Header'])):
headerTableWidget.setSectionResizeMode(
numCell, QHeaderView.ResizeToContents)
# -- Set the First Column to Resizeable
# headerTableWidget.setSectionResizeMode(0, QHeaderView.Stretch)
# -- Set the Last Column to Resizeable
headerTableWidget.setSectionResizeMode(maxTableColumn - 1,
QHeaderView.Stretch)
# -- Add Double Clicked Event on Table
self.main_table.itemDoubleClicked.connect(
self.eventMainTableDoubleClickedOnCell)
# -- Insert Data into Table
self.insertDataIntoTable(self.main_table, hostsList)
# ------------------------------------------
# -- Double Clicked on Cell Event
# ------------------------------------------
def eventMainTableDoubleClickedOnCell(self):
connectParameters = ''
row = self.main_table.currentRow()
# print('Double Clicked on a Table Cell') # -- Debug
for column in self.config_data_file['Table']['Column']['Connect']:
cellTable = self.main_table.item(row, column)
connectParameters += ' ' + str(cellTable.text())
self.connectExecute(connectParameters)
# ------------------------------------------
# -- Insert Data into the Table
# ------------------------------------------
def insertDataIntoTable(self, inputTable, inputRecords):
maxHeaderColumn = len(self.config_data_file['Table']['Header'])
maxTableColumn = len(self.config_data_file['Table']['Header'])
maxTableRow = len(inputRecords)
colorColumn = self.config_data_file['Table']['Column']['Color']
numRecord = 0
numCell = 0
# -- Set the Maximum size of Table
inputTable.setColumnCount(maxTableColumn)
inputTable.setRowCount(maxTableRow)
for record in inputRecords:
# print('Record : %s' %(str(record))) # -- Debug
for cell in record:
# print('Cell : %s' %(cell)) # -- Debug
if (numCell < maxHeaderColumn):
inputTable.setItem(numRecord, numCell,
QTableWidgetItem(cell))
# -- Set the Background Color of Cells
# if (record[colorColumn] in self.colorCell):
# inputTable.item(numRecord, numCell).setBackground(self.colorCell[record[colorColumn]])
if (record[colorColumn] in self.config_data_file['Table']
['Cell']['Color']):
nameColor = self.config_data_file['Table']['Cell'][
'Color'][record[colorColumn]]
# print('Cell: %s, %s, %s' %(record[colorColumn], nameColor, self.color_data[nameColor])) # -- Debug
inputTable.item(numRecord, numCell).setBackground(
self.color_data[nameColor])
numCell += 1
numCell = 0
numRecord += 1
inputTable.move(0, 0)
# ------------------------------------------
# -- Refresh Table
# ------------------------------------------
def refreshTable(self, searchText):
found = False
filteredHostsList = []
# print('Refresh table data.') # -- Debug
# -- Clean the Table
for row in range(self.main_table.rowCount() - 1, -1, -1):
# print('Remove row: %s' %(str(row))) # -- Debug
self.main_table.removeRow(row)
self.main_table.show()
# -- Update the table_data_file with searchText
for record in self.table_data_file:
found = False
for cell in record:
if (searchText == ''
or cell.lower().find(searchText.lower()) != -1):
# print('Found: %s' %(str(cell))) # -- Debug
found = True
if (found):
filteredHostsList.append(record)
# -- Recreate Table Data with filtered Values
self.insertDataIntoTable(self.main_table, filteredHostsList)
# -- Refresh the QTableWidget (required due to screen artifact)
self.main_table.hide()
self.main_table.show()
# ------------------------------------------
# -- Read Config File
# ------------------------------------------
def readConfigFile(self, filename):
fileHandle = None
message = ''
try:
fileHandle = open(filename, 'r')
except IOError:
message = self.messages['FileReadFailed'] + filename
print(message)
# -- Message
if (self.config_data_file['Message']['FileReadFailed'] is True):
self.addNewMessage(message)
else:
message = self.messages['FileReadSuccess'] + filename
print(message)
# -- Update the Default Data Values with the New Ones
# self.config_data_file = json.load(fileHandle)
self.config_data_file.update(json.load(fileHandle))
# -- Add Colors to the List
for key, value in self.config_data_file['Color'].items():
# -- Check the Length of Value (must have 3 elements [R,G,B])
if (len(value) == 3):
self.addColor(key, value[0], value[1], value[2])
# -- Message
if (self.config_data_file['Message']['FileReadSuccess'] is True):
self.addNewMessage(message)
# print('JSON: %s' %(self.config_data_file)) # -- Debug
finally:
if (fileHandle):
fileHandle.close()
# ------------------------------------------
# -- Add Color to the Dictionary
# ------------------------------------------
def addColor(self, name, red, green, blue):
# print('Add Color: %s [%d,%d,%d]' %(name, red, green, blue)) # -- Debug
# -- Check Red
if (type(red) is int):
if (red < 0 or red > 255):
red = 255
else:
red = 255
# -- Check Green
if (type(green) is int):
if (green < 0 or green > 255):
green = 255
else:
green = 255
# -- Check Blue
if (type(blue) is int):
if (blue < 0 or blue > 255):
blue = 255
else:
blue = 255
# print('Add Color: %s [%d,%d,%d]' %(name, red, green, blue)) # -- Debug
# -- Add the Color to the Dictionary
if (name not in self.color_data):
self.color_data[name] = QColor(red, green, blue)
else:
# -- Message
if (self.config_data_file['Message']['ColorRedefinition'] is True):
self.addNewMessage(self.messages['ColorRedefinition'] + name)
# ------------------------------------------
# -- Read CSV File
# ------------------------------------------
def readCsvFile(self, filename):
fileHandle = None
result = []
message = ''
try:
fileHandle = open(filename, 'r')
except IOError:
message = self.messages['FileReadFailed'] + filename
print(message)
# -- Message
if (self.config_data_file['Message']['FileReadFailed'] is True):
self.addNewMessage(message)
else:
message = self.messages['FileReadSuccess'] + filename
print(message)
# -- Message
if (self.config_data_file['Message']['FileReadSuccess'] is True):
self.addNewMessage(message)
fileContent = fileHandle.readlines()
for line in fileContent:
strippedLine = line.strip()
if (strippedLine != ''):
if (strippedLine[0] != '#'):
# result.append(list(strippedLine.split(self.delimiter_table_row))) # -- List Items are not Stripped
result.append(
list(item.strip() for item in strippedLine.split(
self.delimiter_table_row))
) # -- List Items are Stripped
# print(strippedLine) # -- Debug
# -- Debug
# for line in result:
# for column in line:
# print('[\'%s\']' %(str(column)), end='')
# print('')
finally:
if (fileHandle):
fileHandle.close()
return result
# ------------------------------------------
# -- Execute the Connect Command in Shell
# ------------------------------------------
def connectExecute(self, parameters):
# print('Run: %s %s' %(self.connect_file, parameters)) # -- Debug
os.system(self.connect_file + ' ' + parameters)
# ------------------------------------------
# -- UI Initialization
# ------------------------------------------
def initUI(self):
# -- Read the Config File
self.readConfigFile(self.config_file)
# -- Read the Table CSV File
self.table_data_file = self.readCsvFile(self.table_file)
# -- Create GUI Elements
self.createCentralWidget()
self.createLayout()
self.createInputBox()
self.createConnectButton(
self.config_data_file['Button']['Connect']['Label'])
self.checkMainTableHeader(self.table_data_file)
self.createMainTable(self.table_data_file)
self.createMessageLabel()
self.createMessageLabelCount()
self.createMessageButton(
self.config_data_file['Button']['Message']['Label'])
self.createStatusBar()
self.updateStatusBar()
# -- Set Window Title
self.setWindowTitle(self.config_data_file['Title']['Label'])
# -- Set Window Geometry
self.setGeometry(self.config_data_file['Window']['Left'],
self.config_data_file['Window']['Top'],
self.config_data_file['Window']['Width'],
self.config_data_file['Window']['Height'])
# -- Set Layout Margins
self.main_layout.setContentsMargins(
self.config_data_file['Margin']['Left'],
self.config_data_file['Margin']['Top'],
self.config_data_file['Margin']['Right'],
self.config_data_file['Margin']['Bottom'])
# -- Set Layout
self.central_widget.setLayout(self.main_layout)
# -- Add Widgets to Layout
self.main_layout.addWidget(self.input_box, 0, 0, 1, 1)
self.main_layout.addWidget(self.connect_button, 0, 1, 1, 1)
self.main_layout.addWidget(self.main_table, 1, 0, 1, 2)
# -- Set Status Bar for QMainWindow
self.setStatusBar(self.status_bar)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle("open video")
self.setGeometry(300, 300, 800, 600)
self.setIcon()
# showing a hint, or tooltip
# self.setToolTip("this is window")
# self.center()
# self.centralwidget = QWidget(self)
# self.setCentralWidget(self.centralwidget)
self.add_menu()
self.create_main_frame()
self.setImageView()
self.statusLabel = QLabel("showing progress")
self.progressbar = QProgressBar()
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
self.createStatusBar()
self.init()
def init(self):
self.file_name = ""
self.timer = QTimer()
self.timer.timeout.connect(self.displayFrame)
def create_main_frame(self):
self.mainWidget = QWidget()
self.setCentralWidget(self.mainWidget)
def open_video(self):
self.fname = QFileDialog.getOpenFileName()
print(self.fname[0])
self.cap = cv2.VideoCapture(self.fname[0])
self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 800)
self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 600)
self.timer.start()
def add_menu(self):
menubar = self.menuBar()
menu = QMenu('File', self) # title and parent
file_action = QAction("Open file", self) # title and parent
file_action.setStatusTip("Select a file to play")
file_action.triggered.connect(self.open_video)
menu.addAction(file_action)
menubar.addMenu(menu)
menubar.setNativeMenuBar(False)
self.statusBar().showMessage("Ready")
def displayFrame(self):
ret, frame = self.cap.read()
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
height, width, channel = frame.shape
bytesPerLine = 3 * width
qImg = QImage(frame.data, width, height, bytesPerLine,
QImage.Format_RGB888)
self.imageView.setPixmap(QPixmap(qImg))
def setImageView(self):
layout = QVBoxLayout()
self.imageView = QLabel("no video input")
layout.addWidget(self.imageView)
self.mainWidget.setLayout(layout)
def setIcon(self):
appIcon = QIcon("Screenshot from 2019-10-15 09-33-25.png")
self.setWindowIcon(appIcon)
def center(self):
qRect = self.frameGeometry()
centerPoint = QDesktopWidget().availableGeometry().center()
qRect.moveCenter(centerPoint)
self.move(qRect.topLeft())
def createStatusBar(self):
self.myStatus = QStatusBar()
# self.myStatus.showMessage("status bar is ready", 3000)
self.progressbar.setValue(10)
self.myStatus.addWidget(self.statusLabel, 1)
self.myStatus.addWidget(self.progressbar, 2)
self.setStatusBar(self.myStatus)
def __init__(self, app, appname, *args, **kwargs):
super().__init__(*args, **kwargs)
self.hide()
#self.setMinimumSize(640, 480)
self.setFixedSize(self.geometry().width(), self.geometry().height())
self.setWindowIcon(QIcon('icon.ico'))
self.setWindowTitle(appname)
# Create menu bar
menu_bar = QMenuBar()
help_menu = menu_bar.addAction('&Help')
about_menu = menu_bar.addAction('A&bout')
exit_menu = menu_bar.addAction('&Exit')
self.setMenuBar(menu_bar)
# Make interface layouts
window = QWidget()
layout = QVBoxLayout()
top_section = QVBoxLayout()
buttons = QGridLayout()
middle_section = QHBoxLayout()
label_section = QHBoxLayout()
range_section = QGridLayout()
clarity_section = QHBoxLayout()
plot_section = QHBoxLayout()
bottom_section = QVBoxLayout()
status_layout = QHBoxLayout()
# Create widgets and items
figure = plt.figure()
canvas = FigureCanvas(figure)
label = QLabel(f'''Welcome to {appname}!
Plot any equation of the form y = f(x).
Use the options below to plot your own equation!''')
help_message = QMessageBox()
help_message.setTextFormat(Qt.RichText)
help_message.setText(f'''<h3>Help</h3>
{appname} lets you plot any equation of the form y = f(x).
<br/>
Enter the function f(x), specify the range of x, and click Plot!
<br/><br/>
Operators : <code>+, -, *, /</code><br/>
Variable : <code>x</code><br/>
Functions : <code>sin, cos, tan</code><br/>
<code>pi</code> : π<br/>
<code>e</code> : Exponential e<br/>
<code>c</code> : Speed of Light<br/>''')
help_message.setStandardButtons(QMessageBox.Ok)
help_message.setWindowTitle(f'{appname} - Help')
self.help = help_message
help_button = QPushButton('Help...')
help_button.clicked.connect(self.help.exec_)
about_message = QMessageBox()
about_message.setWindowTitle(f'{appname} - About')
about_message.setTextFormat(Qt.RichText)
about_message.setText(f'''<h3>About</h3>
{appname} is created in PySide2 (Qt), using \
the Matplotlib and Equation PyPI modules for plotting and parsing expressions respectively.
<br/><br/>
Created by <a href="http://paramsid.com">Param Siddharth</a>.''')
about_message.setStandardButtons(QMessageBox.Ok)
self.about = about_message
about_button = QPushButton('About...')
about_button.clicked.connect(self.about.exec_)
expr_label = QLabel('f(x) =')
expr_input = QLineEdit()
range_label1 = QLabel('Minimum (x):')
range_min = QLineEdit()
range_label2 = QLabel('Maximum (x):')
range_max = QLineEdit()
clarity_label = QLabel('Clarity:')
clarity_spinbox = QSpinBox()
clarity_spinbox.setRange(1, 10000)
clarity_spinbox.setValue(100)
plot_button = QPushButton('Plot')
plot_button.setMaximumWidth(200)
status = QStatusBar()
status_text = QLabel('')
status_text.setStyleSheet('color: #999999;')
attribution = QLabel(
'Made with <span style="color: red;">❤</span> by <a href="http://paramsid.com">Param</a>'
)
attribution.setTextFormat(Qt.RichText)
attribution.setStyleSheet('color: #555555; font-size: 20px;')
attribution.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
help_menu.triggered.connect(self.help.exec_)
about_menu.triggered.connect(self.about.exec_)
exit_menu.triggered.connect(self.close)
# Configure backend
backmath.configure(canvas=canvas,
figure=figure,
btn=plot_button,
text=expr_input,
limits=(range_min, range_max),
status=status_text,
range_text=(range_min, range_max),
clarity=clarity_spinbox)
# Finalize and display
top_section.addWidget(canvas)
buttons.addWidget(help_button, 0, 0, 1, 1)
buttons.addWidget(about_button, 0, 1, 1, 1)
middle_section.addWidget(label)
middle_section.addLayout(buttons)
label_section.addWidget(expr_label)
label_section.addWidget(expr_input)
equally_spaced = QSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
equally_spaced.setHorizontalStretch(1)
range_label1.setSizePolicy(equally_spaced)
range_min.setSizePolicy(equally_spaced)
range_label2.setSizePolicy(equally_spaced)
range_max.setSizePolicy(equally_spaced)
range_label1.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
range_label2.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
range_section.addWidget(range_label1, 0, 0, 1, 1)
range_section.addWidget(range_min, 0, 1, 1, 1)
range_section.addWidget(range_label2, 0, 2, 1, 1)
range_section.addWidget(range_max, 0, 3, 1, 1)
clarity_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
clarity_section.addWidget(clarity_label)
clarity_section.addWidget(clarity_spinbox)
plot_section.addWidget(plot_button)
status.addWidget(status_text)
status.addPermanentWidget(attribution)
status_layout.addWidget(status)
bottom_section.addLayout(label_section)
bottom_section.addLayout(range_section)
bottom_section.addLayout(clarity_section)
bottom_section.addLayout(plot_section)
layout.addLayout(top_section)
layout.addLayout(middle_section)
layout.addLayout(bottom_section)
layout.addLayout(status_layout)
window.setLayout(layout)
self.setCentralWidget(window)
self.show()
status_text.setText('READY ')
