def __init__(self):
super(MainWindow, self).__init__()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.scene = QGraphicsScene()
self.ui.graficos.setScene(self.scene)
self.ui.agregar_inicio_button.clicked.connect(self.agregar_ini)
self.ui.agregar_final_button.clicked.connect(self.agregar_fin)
self.ui.mostrar_button.clicked.connect(self.mostrar)
self.ui.buscar_button.clicked.connect(self.buscar)
self.ui.mostrar_tabla_button.clicked.connect(self.mostrar_tabla)
self.ui.dibujar_button.clicked.connect(self.dibujar)
self.ui.limpiar_button.clicked.connect(self.limpiar)
self.ui.generar_button.clicked.connect(self.generar)
self.ui.actionAbrir.triggered.connect(self.abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.guardar_archivo)
self.ui.actionGrafo.triggered.connect(self.generar_grafo)
self.ui.actionRecorrido.triggered.connect(self.recorrido)
self.ui.id_checkbox.stateChanged.connect(self.ordenar_id)
self.ui.velocidad_checkbox.stateChanged.connect(self.ordenar_vel)
self.ui.distancia_checkbox.stateChanged.connect(self.ordenar_dis)
def __init__(self):
# Initialize attributes of QtWidgets.QMainWindow
if 3 > sys.version_info[0]:
# Python 2
super(MainWindow, self).__init__()
else:
# Python 3
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Map labelCanvas pointer to the real instance
self.labelCanvas = self.ui.labelCanvas
self.imgList = Images(self.ui.listWidgetImgList)
# Actions
self.ui.actionImport.triggered.connect(self.actionImportClickEvt)
self.ui.actionEdit.triggered.connect(self.actionEditClickEvt)
self.ui.actionExit.triggered.connect(self.actionExitClickEvt)
self.ui.listWidgetImgList.currentItemChanged.connect(
self.actionCurrentItemChangedEvt)
self.show()
def __init__(self):
super(MainWindow, self).__init__()
# Set up the user interface from Designer.
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Make some local modifications.
# self.ui.colorDepthCombo.addItem("2 colors (1 bit per pixel)")
# Initial stuff
self.ui.rootX0.setEnabled(False)
self.ui.rootX1.setEnabled(False)
# Connect up the buttons.
self.ui.rootComboBox.activated.connect(self.changeRootMethod)
self.ui.rootSolveBtn.clicked.connect(self.rootSolve)
self.ui.interpolationSolveBtn.clicked.connect(self.interpolationSolve)
self.ui.sysAddBtn.clicked.connect(self.sysAdd)
self.ui.sysRemoveBtn.clicked.connect(self.sysRemove)
self.ui.sysSolveBtn.clicked.connect(self.sysSolve)
self.ui.rootLoadBtn.clicked.connect(self.rootLoadFile)
self.ui.interpolationLoadBtn.clicked.connect(self.interpolationLoadFile)
self.ui.sysLoadBtn.clicked.connect(self.sysLoadFile)
self.meme_count = 0
self.ui.memeBtn.clicked.connect(self.meme)
self.ui.memeLabel.setVisible(False)
self.ui.memeLabel.setPixmap(QPixmap("doge.jpg"))
self.ui.memeText.setVisible(False)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.actionExit.triggered.connect(QApplication.instance().exit)
self.ui.actionAbout.triggered.connect(self._on_action_about_triggered)
self.ui.tableWidget.setColumnCount(5)
self.ui.tableWidget.setHorizontalHeaderLabels(
['Header', 'Author', 'Url', 'Count comments', 'Count likes'])
self.init_table_widget()
self.ui.tableWidget.resizeColumnsToContents()
def _on_action_about_triggered(self):
QMessageBox.about(self, 'About', 'Chuvaev Pavel\n8-Т3О-302Б-16')
def init_table_widget(self):
posts = html_parser.load_habr_news_posts()
i = 0
self.ui.tableWidget.setRowCount(len(posts))
for post in posts:
self.ui.tableWidget.setItem(i, 0, QTableWidgetItem(post['title']))
self.ui.tableWidget.setItem(i, 1, QTableWidgetItem(post['author']))
self.ui.tableWidget.setItem(i, 2, QTableWidgetItem(post['href']))
self.ui.tableWidget.setItem(i, 3, QTableWidgetItem(post['comms']))
self.ui.tableWidget.setItem(i, 4, QTableWidgetItem(post['votes']))
i += 1
def __init__(self):
super(MainWindow, self).__init__()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_inicio_button.clicked.connect(self.agregar_ini)
self.ui.agregar_final_button.clicked.connect(self.agregar_fin)
self.ui.mostrar_button.clicked.connect(self.mostrar)
def __init__(self):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# MAIN WINDOW LABEL
QtCore.QTimer.singleShot(1500, lambda: self.ui.label.setText("<strong>THANKS</strong> FOR WATCHING"))
QtCore.QTimer.singleShot(1500, lambda: self.setStyleSheet("background-color: #222; color: #FFF"))
class MainWindow(WindowWrapper):
### Constructor
def __init__(self):
# Initialize attributes of QtWidgets.QMainWindow
if 3 > sys.version_info[0]:
# Python 2
super(MainWindow, self).__init__()
else:
# Python 3
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Map labelCanvas pointer to the real instance
self.labelCanvas = self.ui.labelCanvas
self.imgList = Images(self.ui.listWidgetImgList)
# Actions
self.ui.actionImport.triggered.connect(self.actionImportClickEvt)
self.ui.actionEdit.triggered.connect(self.actionEditClickEvt)
self.ui.actionExit.triggered.connect(self.actionExitClickEvt)
self.ui.listWidgetImgList.currentItemChanged.connect(
self.actionCurrentItemChangedEvt)
self.show()
### Destructor
def __del__(self):
LOG(self, 'Finalizing ' + self.windowTitle() + ' Window')
### Event Handlers
# Display Current Item when it changed
def actionCurrentItemChangedEvt(self):
# Get selected row index
currentRow = self.ui.listWidgetImgList.currentRow()
# Display selected image
self.display(self.imgList.images[currentRow])
# Enable Edit Action
self.ui.actionEdit.setEnabled(True)
# Import images
def actionImportClickEvt(self):
self.imgList.importImages()
# Edit selected image
def actionEditClickEvt(self):
selectedIndex = self.ui.listWidgetImgList.currentRow()
selectedImg = self.imgList.images[selectedIndex]
editor = EditorWindow(self, selectedImg)
self.subWidgets.append(editor)
# Exit
def actionExitClickEvt(self):
self.close()
def __init__(self):
super(MainWindow, self).__init__()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_inicio_button.clicked.connect(self.agregar_ini)
self.ui.agregar_final_button.clicked.connect(self.agregar_fin)
self.ui.mostrar_button.clicked.connect(self.mostrar)
self.ui.actionAbrir.triggered.connect(self.abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.guardar_archivo)
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self._thread = QThread()
self._input_filename = None
self._p_threaded = None
self.get_input_filename()
self.start_thread()
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.actionExit.triggered.connect(QApplication.instance().exit)
self.ui.actionAbout.triggered.connect(self._on_action_about_triggered)
self.ui.tableWidget.setColumnCount(5)
self.ui.tableWidget.setHorizontalHeaderLabels(
['Header', 'Author', 'Url', 'Count comments', 'Count likes'])
self.init_table_widget()
self.ui.tableWidget.resizeColumnsToContents()
def __init__(self, sysbus, parent=None):
QtGui.QWidget.__init__(self, parent)
# Init ourself from the Designer UI
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# light up the admin interface
self.admin = AdminInterface(SERVICE, '/org/ganesha/nfsd/admin', sysbus,
self.show_status)
self.exportmgr = ExportMgr(SERVICE, '/org/ganesha/nfsd/ExportMgr',
sysbus, self.show_status)
self.clientmgr = ClientMgr(SERVICE, '/org/ganesha/nfsd/ClientMgr',
sysbus, self.show_status)
self.logmanager = LogManager(SERVICE, sysbus, self.show_status)
self.logdialog = LogSetDialog(self.logmanager)
self.show_status.connect(self.status_message)
# Connect up the ui menubar
#File
self.ui.actionDBus_connect.triggered.connect(self.connect_gsh)
self.ui.actionQuit.triggered.connect(self.quit)
#Manage
#Manage->Clients
self.ui.actionAdd_Client.triggered.connect(self.add_client)
self.ui.actionRemove_Client.triggered.connect(self.remove_client)
#Manage->Exports
self.ui.actionExports.triggered.connect(self.export_mgr)
#Manage->Log Levels
self.ui.actionLog_Settings.triggered.connect(self.logsettings)
#Manage->Admin
self.ui.actionReset_Grace.triggered.connect(self.reset_grace)
self.ui.actionShutdown.triggered.connect(self.shutdown)
self.ui.actionReload.triggered.connect(self.reload)
#View
self.ui.actionStatistics.triggered.connect(self.stats)
self.ui.actionViewExports.triggered.connect(self.view_exports)
self.ui.actionViewClients.triggered.connect(self.view_clients)
#Help
self.ui.actionAbout.triggered.connect(self.help)
# Dbus data models
self.exports_show_model = ExportTableModel(self.exportmgr)
self.clients_show_model = ClientTableModel(self.clientmgr)
# Tabs, tables, and views
self.ui.exports.setModel(self.exports_show_model)
self.ui.exports.resizeColumnsToContents()
self.ui.exports.verticalHeader().setVisible(False)
self.ui.clients.setModel(self.clients_show_model)
self.ui.clients.resizeColumnsToContents()
self.ui.clients.verticalHeader().setVisible(False)
def __init__(self):
super(MainWindow, self).__init__()
self.resize(400, 600)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.layout = QtWidgets.QHBoxLayout(self.ui.main_page)
self.splitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
self.left_side = LeftSide()
self.splitter.addWidget(self.left_side)
self.central_side = CentralSide()
self.splitter.addWidget(self.central_side)
self.right_side = RightSide()
self.splitter.addWidget(self.right_side)
self.layout.addWidget(self.splitter)
def __init__(self, sysbus, parent=None):
QtGui.QWidget.__init__(self, parent)
# Init ourself from the Designer UI
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# light up the admin interface
self.admin = AdminInterface(SERVICE,
'/org/ganesha/nfsd/admin',
sysbus,
self.show_status)
self.exportmgr = ExportMgr(SERVICE,
'/org/ganesha/nfsd/ExportMgr',
sysbus,
self.show_status)
self.clientmgr = ClientMgr(SERVICE,
'/org/ganesha/nfsd/ClientMgr',
sysbus,
self.show_status)
self.logmanager = LogManager(SERVICE,
sysbus,
self.show_status)
self.logdialog = LogSetDialog(self.logmanager)
self.show_status.connect(self.status_message)
# Connect up the ui menubar
#File
self.ui.actionDBus_connect.triggered.connect(self.connect_gsh)
self.ui.actionQuit.triggered.connect(self.quit)
#Manage
#Manage->Clients
self.ui.actionAdd_Client.triggered.connect(self.add_client)
self.ui.actionRemove_Client.triggered.connect(self.remove_client)
#Manage->Exports
self.ui.actionExports.triggered.connect(self.export_mgr)
#Manage->Log Levels
self.ui.actionLog_Settings.triggered.connect(self.logsettings)
#Manage->Admin
self.ui.actionReset_Grace.triggered.connect(self.reset_grace)
self.ui.actionShutdown.triggered.connect(self.shutdown)
self.ui.actionReload.triggered.connect(self.reload)
#View
self.ui.actionStatistics.triggered.connect(self.stats)
self.ui.actionViewExports.triggered.connect(self.view_exports)
self.ui.actionViewClients.triggered.connect(self.view_clients)
#Help
self.ui.actionAbout.triggered.connect(self.help)
# Dbus data models
self.exports_show_model = ExportTableModel(self.exportmgr)
self.clients_show_model = ClientTableModel(self.clientmgr)
# Tabs, tables, and views
self.ui.exports.setModel(self.exports_show_model)
self.ui.exports.resizeColumnsToContents()
self.ui.exports.verticalHeader().setVisible(False)
self.ui.clients.setModel(self.clients_show_model)
self.ui.clients.resizeColumnsToContents()
self.ui.clients.verticalHeader().setVisible(False)
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.next_button.setEnabled(False)
# self.ui.next_button.clicked.connect(self.goToNext)
self.ui.next_button.clicked.connect(self.goToNext)
self.ui.prev_button.setEnabled(False)
self.ui.prev_button.clicked.connect(self.goToPrev)
self.page_index = {
"page_connect": self.ui.stackedWidget.indexOf(self.ui.page_connect),
"page_system_check": self.ui.stackedWidget.indexOf(self.ui.page_system_check),
"page_select_subassembly": self.ui.stackedWidget.indexOf(self.ui.page_select_subassembly),
"page_subassembly_overview": self.ui.stackedWidget.indexOf(self.ui.page_subassembly_overview),
"page_machine": self.ui.stackedWidget.indexOf(self.ui.page_machine)
}
print(self.page_index)
self.ui.stackedWidget.currentChanged.connect(self.handlePageChange)
# set connect as first page
self.ui.stackedWidget.setCurrentIndex(self.page_index['page_connect'])
# todo: only start after camera connect!
self.th = CameraThread(self)
self.th.changePixmap.connect(self.setImage)
self.setupConnect()
self.connected_devices = 0
# system check setup
self.setup_system_check()
self.machineThread = MachineThread()
self.setupMachine()
# page select subassembly
self.ui.treeWidget.expandAll()
self.ui.treeWidget.itemClicked.connect(self.handleTreeSelect)
self.SelectSubassembly.connect(lambda x: self.ui.selected_status.setText(x))
self.SelectSubassembly.connect(lambda x: self.ui.selected_status_2.setText(x))
self.SelectSubassembly.connect(lambda x: self.ui.selected_status_3.setText(x))
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.moodbox.addItems(self.moods)
self.update_title(False)
self.ui.all_buttons.setEnabled(False)
# Dropdown events
self.ui.actionLoad_episode.triggered.connect(self.load_episode)
self.ui.actionSave_changes.triggered.connect(self.save_changes)
self.ui.actionAdd_audio_path.triggered.connect(self.add_audio_path)
self.ui.actionGenerate_Audacity_labels.triggered.connect(
lambda: self.export_to_labels(None))
self.ui.actionExport_dataset.triggered.connect(self.export_dataset)
self.ui.actionGenerate_Audacity_labels_all_episodes.triggered.connect(
lambda: self.export_all_labels(None))
# Previous/next events
self.ui.button_next.clicked.connect(lambda: self.next_label(False))
self.ui.button_previous.clicked.connect(lambda: self.next_label(True))
# Listen/choose events
self.ui.button_listenorig.clicked.connect(
lambda: self.listen_to_source(0))
self.ui.button_listenizo.clicked.connect(
lambda: self.listen_to_source(1))
self.ui.button_listenunmix.clicked.connect(
lambda: self.listen_to_source(2))
self.ui.button_chooseorig.clicked.connect(
lambda: self.choose_source(0))
self.ui.button_chooseizo.clicked.connect(lambda: self.choose_source(1))
self.ui.button_chooseunmix.clicked.connect(
lambda: self.choose_source(2))
# Other events
self.ui.startbox.valueChanged.connect(lambda: self.update_title(True))
self.ui.endbox.valueChanged.connect(lambda: self.update_title(True))
self.ui.characterbox.textChanged.connect(
lambda: self.update_title(True))
self.ui.moodbox.currentIndexChanged.connect(
lambda: self.update_title(True))
self.ui.transcriptbox.textChanged.connect(
lambda: self.update_title(True))
self.ui.radio_clean.clicked.connect(lambda: self.update_title(True))
self.ui.radio_noisy.clicked.connect(lambda: self.update_title(True))
self.ui.radio_verynoisy.clicked.connect(
lambda: self.update_title(True))
# End of events
self.scan_for_files()
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.game.hide()
self.ui.aquarium.pause()
self.connect_buttons()
self.ui.aquarium.score_changed.connect(self.change_score)
self.change_score()
def main():
#Setup QtApp
app = QtGui.QApplication(sys.argv[0])
ui_mainwindow = Ui_MainWindow()
main_window = MainWindow(app, ui_mainwindow, viz_config)
main_window.show()
sys.exit(app.exec_())
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_inicio_button.clicked.connect(self.agregar_ini)
self.ui.agregar_final_button.clicked.connect(self.agregar_fin)
self.ui.mostrar_button.clicked.connect(self.mostrar)
@Slot()
def agregar_ini(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id, or_x, or_y, ds_x, ds_y, vel, red, grn, blu)
self.organizador.agregar_inicio(part)
@Slot()
def agregar_fin(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id, or_x, or_y, ds_x, ds_y, vel, red, grn, blu)
self.organizador.agregar_final(part)
def mostrar(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(str(self.organizador))
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self._thread = QThread()
self._input_filename = None
self._main_video_file = None
self._p_threaded = None
self.get_input_filename()
self.start_thread()
def get_input_filename(self):
self._input_filename = 'MVI_9429_small_tracked-14842-21722-2.csv'
# main video file
# self._main_video_file = self._input_filename[:14] + '.mp4'
self._main_video_file = self._input_filename[:8] + '.MOV'
def start_thread(self):
self._p_threaded = VideoProcTracked(cv2.VideoCapture(
self._main_video_file),
in_file_name=self._input_filename,
preview_window_manager=None,
should_mirror_preview=True)
self._thread.started.connect(self._p_threaded.start_video)
# pthread.finished.connect(self.deleteLater())
self._p_threaded.in_display.connect(self.ui.in_video.setPixmap)
self._p_threaded.out_display.connect(self.ui.out_video.setPixmap)
self._p_threaded.moveToThread(self._thread)
self._thread.start()
def closeEvent(self, event):
print("closing out thread before closing window")
self._p_threaded.stop_video()
self._thread.quit()
self._thread.wait()
print("done waiting for thread to close")
event.accept()
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.game.hide()
self.ui.aquarium.pause()
self.connect_buttons()
self.ui.aquarium.score_changed.connect(self.change_score)
self.change_score()
def connect_buttons(self):
self.ui.buy_fish.clicked.connect(self.ui.aquarium.spawn_fish)
self.ui.upgrade_weapon.clicked.connect(self.ui.aquarium.upgrade_weapon)
self.ui.upgrade_food.clicked.connect(self.ui.aquarium.upgrade_food)
self.ui.upgrade_food.clicked.connect(self.ui.aquarium.upgrade_food)
self.ui.menu.clicked.connect(self.open_menu)
self.ui.start_game.clicked.connect(self.close_menu)
self.ui.exit.clicked.connect(self.close)
@QtCore.pyqtSlot()
def close_menu(self):
self.ui.game.show()
self.ui.main_menu.hide()
self.ui.aquarium.unpause()
@QtCore.pyqtSlot()
def open_menu(self):
self.ui.aquarium.pause()
self.ui.game.hide()
self.ui.main_menu.show()
@QtCore.pyqtSlot()
def change_score(self):
self.ui.score.setText(str(self.ui.aquarium.score))
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.close()
def __init__(self, parent = None): QMainWindow.__init__(self, parent) self.data = None self.image = None self.printer = Printer(self) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.setActions() self.loadSettings() self.setState(STATE_INIT)
class MainWindow(QtGui.QMainWindow):
show_status = QtCore.pyqtSignal(bool, str)
def __init__(self, sysbus, parent=None):
QtGui.QWidget.__init__(self, parent)
# Init ourself from the Designer UI
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# light up the admin interface
self.admin = AdminInterface(SERVICE, '/org/ganesha/nfsd/admin', sysbus,
self.show_status)
self.exportmgr = ExportMgr(SERVICE, '/org/ganesha/nfsd/ExportMgr',
sysbus, self.show_status)
self.clientmgr = ClientMgr(SERVICE, '/org/ganesha/nfsd/ClientMgr',
sysbus, self.show_status)
self.logmanager = LogManager(SERVICE, sysbus, self.show_status)
self.logdialog = LogSetDialog(self.logmanager)
self.show_status.connect(self.status_message)
# Connect up the ui menubar
#File
self.ui.actionDBus_connect.triggered.connect(self.connect_gsh)
self.ui.actionQuit.triggered.connect(self.quit)
#Manage
#Manage->Clients
self.ui.actionAdd_Client.triggered.connect(self.add_client)
self.ui.actionRemove_Client.triggered.connect(self.remove_client)
#Manage->Exports
self.ui.actionExports.triggered.connect(self.export_mgr)
#Manage->Log Levels
self.ui.actionLog_Settings.triggered.connect(self.logsettings)
#Manage->Admin
self.ui.actionReset_Grace.triggered.connect(self.reset_grace)
self.ui.actionShutdown.triggered.connect(self.shutdown)
self.ui.actionReload.triggered.connect(self.reload)
#View
self.ui.actionStatistics.triggered.connect(self.stats)
self.ui.actionViewExports.triggered.connect(self.view_exports)
self.ui.actionViewClients.triggered.connect(self.view_clients)
#Help
self.ui.actionAbout.triggered.connect(self.help)
# Dbus data models
self.exports_show_model = ExportTableModel(self.exportmgr)
self.clients_show_model = ClientTableModel(self.clientmgr)
# Tabs, tables, and views
self.ui.exports.setModel(self.exports_show_model)
self.ui.exports.resizeColumnsToContents()
self.ui.exports.verticalHeader().setVisible(False)
self.ui.clients.setModel(self.clients_show_model)
self.ui.clients.resizeColumnsToContents()
self.ui.clients.verticalHeader().setVisible(False)
# actions to real work...
def quit(self):
self.statusBar().showMessage("Bye bye kiddies, quitting")
quit()
def connect_gsh(self):
self.statusBar().showMessage("Connecting to nfs-ganesha...")
def add_client(self):
ipaddr, ok = QtGui.QInputDialog.getText(
self, 'Add a Client', 'IP Address (N.N.N.N) of client: ')
if ok:
self.clientmgr.AddClient(ipaddr)
def remove_client(self):
ipaddr, ok = QtGui.QInputDialog.getText(
self, 'Remove a Client', 'IP Address (N.N.N.N) of client: ')
if ok:
self.clientmgr.RemoveClient(ipaddr)
def export_mgr(self):
self.statusBar().showMessage("Export manager")
def logsettings(self):
self.logdialog.show_logsetting_dialog()
def reset_grace(self):
ipaddr, ok = QtGui.QInputDialog.getText(
self, 'Grace Period', 'IP Address (N.N.N.N) of client: ')
if ok:
self.admin.grace(ipaddr)
def shutdown(self):
reply = QtGui.QMessageBox.question(
self, 'Warning!!!', "Do you really want to shut down the server?",
QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
self.admin.shutdown()
def reload(self):
reply = QtGui.QMessageBox.question(
self, 'Warning!!!', "Do you really want to reload exports?",
QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
self.admin.reload()
def stats(self):
self.statusBar().showMessage("stats go here")
def view_exports(self):
self.exports_show_model.FetchExports()
def view_clients(self):
self.clients_show_model.FetchClients()
def help(self):
self.statusBar().showMessage("Help! Help!!")
def status_message(self, status, errormsg):
if status:
str = "Success: "
else:
str = "Failed: "
self.statusBar().showMessage(str + errormsg)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
# Set up the user interface from Designer.
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Make some local modifications.
# self.ui.colorDepthCombo.addItem("2 colors (1 bit per pixel)")
# Initial stuff
self.ui.rootX0.setEnabled(False)
self.ui.rootX1.setEnabled(False)
# Connect up the buttons.
self.ui.rootComboBox.activated.connect(self.changeRootMethod)
self.ui.rootSolveBtn.clicked.connect(self.rootSolve)
self.ui.interpolationSolveBtn.clicked.connect(self.interpolationSolve)
self.ui.sysAddBtn.clicked.connect(self.sysAdd)
self.ui.sysRemoveBtn.clicked.connect(self.sysRemove)
self.ui.sysSolveBtn.clicked.connect(self.sysSolve)
self.ui.rootLoadBtn.clicked.connect(self.rootLoadFile)
self.ui.interpolationLoadBtn.clicked.connect(self.interpolationLoadFile)
self.ui.sysLoadBtn.clicked.connect(self.sysLoadFile)
self.meme_count = 0
self.ui.memeBtn.clicked.connect(self.meme)
self.ui.memeLabel.setVisible(False)
self.ui.memeLabel.setPixmap(QPixmap("doge.jpg"))
self.ui.memeText.setVisible(False)
def changeRootMethod(self):
index = self.ui.rootComboBox.currentIndex()
if index == 0:
self.ui.rootX0.setEnabled(False)
self.ui.rootX1.setEnabled(False)
elif index in [1, 2, 5, 7]:
self.ui.rootX0.setEnabled(True)
self.ui.rootX1.setEnabled(True)
else:
self.ui.rootX0.setEnabled(True)
self.ui.rootX1.setEnabled(False)
if index == 5:
self.ui.rootX1Label.setText(" Multiplicity")
else:
self.ui.rootX1Label.setText(" X1")
def rootSolve(self):
try:
expression = self.ui.rootFx.text()
method_name = self.ui.rootComboBox.currentText()
inital_points = []
if self.ui.rootX0.isEnabled():
inital_points.append(self.ui.rootX0.value())
if self.ui.rootX1.isEnabled():
inital_points.append(self.ui.rootX1.value())
max_iterations = self.ui.rootMaxIterations.value()
percision = self.ui.rootPercision.value()
f = sympy.lambdify('x', expression)
factory = RootFinderFactory()
if method_name == "General Algorithm":
results, PlotWindow, Datatable = factory.solve(method_name, expression, max_iterations, percision)
rw = ResultWindow(self, PlotWindow, Datatable, {"general_results": results})
else:
results, PlotWindow, Datatable = factory.solve(method_name, expression, *inital_points, max_iterations, percision)
rw = ResultWindow(self, PlotWindow, Datatable, {"results": results})
rw.show()
except Exception as e:
self.errorDialog(e.args[0])
def interpolationSolve(self):
try:
try:
sample_points = literal_eval(self.ui.interpolationSampleLineEdit.text())
except Exception as e:
raise Exception("Invalid sample points, Enter sample points in the form of comma seperated order pairs.\n"
"Example: (0, 1), (2.25, 3), (4, 6.5)")
max_x = max(sample_points)[0]
min_x = min(sample_points)[0]
queries = self.ui.interpolationQueryLineEdit.text().split(',')
if len(queries) == 0:
raise Exception("Invalid query points. Enter query points in the form of comma separated values.\n"
"Example: 1, 2, 2.5, 3")
for q in queries:
try:
x = float(q)
except Exception as a:
raise Exception("Invalid query points. Enter query points in the form of comma separated values.\n"
"Example: 1, 2, 2.5, 3")
if x < min_x or x > max_x:
raise Exception("Invalid query point {:f}, point is out of the range of sample points.".format(x))
interpolation = interpolate(sample_points)
method_index = self.ui.interpolationComboBox.currentIndex()
if method_index == 0:
sym_function = interpolation.newoten_method()
else:
sym_function = interpolation.lagrange()
f = sympy.lambdify('x', sym_function)
rw = ResultWindow(self, interpolation_controller.PlotWindow, interpolation_controller.DataTable,
{"f": f, "queries": queries,'expr': sym_function})
rw.show()
except Exception as e:
self.errorDialog(e.args[0])
def sysSolve(self):
try:
equations = []
for i in range(1, self.ui.sysEqnsForm.rowCount()*2, 2):
equations.append(self.ui.sysEqnsForm.itemAt(i).widget().text())
solver = GaussJordan()
results = solver.solve(equations)
print(results)
rw = ResultWindow(self, None, gauss_jordan_controller.DataTable, {"results": results})
rw.show()
except Exception as e:
self.errorDialog(e.args[0])
def sysAdd(self):
if self.ui.sysEqnsForm.rowCount() < 10:
eqn_number = str(self.ui.sysEqnsForm.rowCount() + 1)
label = QtWidgets.QLabel(" Equation " + eqn_number)
label.setObjectName("sysEqn" + eqn_number + "Label")
lineEdit = QtWidgets.QLineEdit()
lineEdit.setObjectName("sysEqn" + eqn_number + "LineEdit")
lineEdit.setPlaceholderText("Example: 2a + 5b - 3c = 5")
self.ui.sysEqnsForm.addRow(label, lineEdit)
def sysRemove(self):
if self.ui.sysEqnsForm.rowCount() > 2:
self.ui.sysEqnsForm.removeRow(self.ui.sysEqnsForm.rowCount() - 1)
def open_file(self):
options = QtWidgets.QFileDialog.Options()
options |= QtWidgets.QFileDialog.DontUseNativeDialog
file_name, _ = QtWidgets.QFileDialog.getOpenFileName()
if file_name:
return file_name
def rootLoadFile(self):
file = self.open_file()
if file:
try:
params = parse_root_finder_file(file)
method_number = params['method']
self.ui.rootFx.setText(params['equation'])
self.ui.rootX0.setValue(params['parameters'][0])
if len(params['parameters']) > 1:
self.ui.rootX1.setValue(params['parameters'][1])
self.ui.rootMaxIterations.setValue(params['iterations'])
self.ui.rootPercision.setValue(params['tolerance'])
if method_number == 7:
method_number = 0
elif method_number > 4:
method_number += 2
self.ui.rootComboBox.setCurrentIndex(method_number)
self.changeRootMethod()
except Exception as e:
self.errorDialog(e.args[0])
def interpolationLoadFile(self):
file = self.open_file()
if file:
try:
params = parse_interpolation_file(file)
method = params['method']
order = params['order']
points = params['points']
queries = params['query_points']
self.ui.interpolationOrderLineEdit.setValue(order)
self.ui.interpolationComboBox.setCurrentIndex(method-1)
self.ui.interpolationQueryLineEdit.setText(str(queries)[1:-1])
self.ui.interpolationSampleLineEdit.setText(str(points)[1:-1])
print(params)
except Exception as e:
self.errorDialog(e.args[0])
def sysLoadFile(self):
file = self.open_file()
if file:
try:
equations = parse_equations_file(file)
for i in range(len(equations)):
if(i < 2):
self.ui.sysEqnsForm.itemAt(2*i + 1).widget().setText(str(equations[i]))
else:
self.sysAdd();
self.ui.sysEqnsForm.itemAt(2*i + 1).widget().setText(str(equations[i]))
except Exception as e:
self.errorDialog(e.args[0])
def errorDialog(self, text="Oh no! Something went wrong."):
msg = QtWidgets.QMessageBox(self)
msg.setIcon(QtWidgets.QMessageBox.Critical)
msg.setText("Error")
msg.setInformativeText(text)
msg.setWindowTitle("Error")
msg.resize(500, msg.height())
msg.show()
def meme(self):
self.meme_count += 1
if self.meme_count >= 10:
self.ui.memeText.setVisible(True)
self.ui.memeLabel.setVisible(True)
class MainWindow(QMainWindow):
SelectSubassembly = Signal(str)
@Slot(QImage)
def setImage(self, image):
# self.ui.label_img_camera.setPixmap(QPixmap.fromImage(image))
self.ui.label_img_camera.setPixmap(QPixmap.fromImage(image).scaled(self.ui.label_img_camera.size(),aspectMode=Qt.KeepAspectRatio))
@Slot(np.ndarray)
def setBoltFrame(self, frame): # np array
self.ui.label_img_bolt.setPixmap(QPixmap.fromImage(frame).scaled(self.ui.label_img_bolt.size(),aspectMode=Qt.KeepAspectRatio))
# self.ui.label_img_bolt.setPixmap(QPixmap.fromImage(frame))
print('received at slot')
@Slot(list)
def updateBoltCounts(self, counts):
print('update_bolt_counts: ',counts)
table = self.ui.tableWidget_2
for i in range(0,table.rowCount()):
item_bolt_type = table.item(i,0)
bolt_type = str(item_bolt_type.text()).lower()
if bolt_type in counts:
print('textinitem:',str(counts[bolt_type]))
item = QTableWidgetItem(str(counts[bolt_type]))
item = table.setItem(i,1,item)
@Slot(list)
def updateProgress(self, counts):
progress = (self.sum_column_table(1)/self.bolts_total)*100
# progress=0.2
print(progress)
self.ui.progressBar.setValue(progress)
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.next_button.setEnabled(False)
# self.ui.next_button.clicked.connect(self.goToNext)
self.ui.next_button.clicked.connect(self.goToNext)
self.ui.prev_button.setEnabled(False)
self.ui.prev_button.clicked.connect(self.goToPrev)
self.page_index = {
"page_connect": self.ui.stackedWidget.indexOf(self.ui.page_connect),
"page_system_check": self.ui.stackedWidget.indexOf(self.ui.page_system_check),
"page_select_subassembly": self.ui.stackedWidget.indexOf(self.ui.page_select_subassembly),
"page_subassembly_overview": self.ui.stackedWidget.indexOf(self.ui.page_subassembly_overview),
"page_machine": self.ui.stackedWidget.indexOf(self.ui.page_machine)
}
print(self.page_index)
self.ui.stackedWidget.currentChanged.connect(self.handlePageChange)
# set connect as first page
self.ui.stackedWidget.setCurrentIndex(self.page_index['page_connect'])
# todo: only start after camera connect!
self.th = CameraThread(self)
self.th.changePixmap.connect(self.setImage)
self.setupConnect()
self.connected_devices = 0
# system check setup
self.setup_system_check()
self.machineThread = MachineThread()
self.setupMachine()
# page select subassembly
self.ui.treeWidget.expandAll()
self.ui.treeWidget.itemClicked.connect(self.handleTreeSelect)
self.SelectSubassembly.connect(lambda x: self.ui.selected_status.setText(x))
self.SelectSubassembly.connect(lambda x: self.ui.selected_status_2.setText(x))
self.SelectSubassembly.connect(lambda x: self.ui.selected_status_3.setText(x))
@Slot(QTreeWidgetItem, int)
def handleTreeSelect(self, item:QTreeWidgetItem, column:int):
a = item.flags()
if bool(Qt.ItemIsSelectable & a):
self.SelectSubassembly.emit(item.parent().text(0) +'/'+ item.text(0))
self.ui.next_button.setEnabled(True)
# def exitSystemCheck(self):
def handlePageChange(self, index):
if index == self.page_index['page_connect']:
print('pg_con')
elif index == self.page_index['page_system_check']:
self.enter_system_check()
elif index == self.page_index['page_select_subassembly']:
self.enter_select_subassembly()
elif index == self.page_index['page_subassembly_overview']:
self.enter_subassembly_overview()
elif index == self.page_index['page_machine']:
self.enter_machine()
def setup_system_check(self):
self.ui.checkBox.clicked.connect(self.check_confirm_release)
self.ui.checkBox_2.clicked.connect(self.check_confirm_release)
self.ui.confirm_button.clicked.connect(lambda:self.ui.next_button.setEnabled(True))
self.ui.confirm_button.clicked.connect(lambda:self.ui.confirm_button.setDisabled(True))
self.ui.confirm_button.clicked.connect(lambda:self.ui.checkBox.setDisabled(True))
self.ui.confirm_button.clicked.connect(lambda:self.ui.checkBox_2.setDisabled(True))
def check_confirm_release(self):
if bool(self.ui.checkBox.checkState()) and bool(self.ui.checkBox_2.checkState()):
self.ui.confirm_button.setEnabled(True)
else:
self.ui.confirm_button.setEnabled(False)
def enter_system_check(self):
self.ui.next_button.setDisabled(True)
self.ui.prev_button.setDisabled(True)
self.ui.confirm_button.setDisabled(True)
self.ui.next_button.setText("Next >>")
self.ui.confirm_button.setText("confirm")
self.ui.checkBox.setCheckState(Qt.Unchecked)
self.ui.checkBox_2.setCheckState(Qt.Unchecked)
self.ui.checkBox.setEnabled(True)
self.ui.checkBox_2.setEnabled(True)
def enter_select_subassembly(self):
self.ui.prev_button.setDisabled(True)
self.ui.next_button.setDisabled(True)
def enter_subassembly_overview(self):
self.ui.prev_button.setEnabled(True)
self.ui.next_button.setEnabled(True)
def enter_machine(self):
self.ui.next_button.setDisabled(True)
self.ui.start_machine_button.setEnabled(True)
self.ui.stop_machine_button.setDisabled(True)
self.ui.progressBar.setValue(0)
def setupMachine(self):
self.bolts_total = self.sum_column_table(2)
print(self.bolts_total)
# add thread to run button
self.ui.start_machine_button.clicked.connect(self.machineThread.start)
self.ui.start_machine_button.clicked.connect(lambda: self.ui.stop_machine_button.setEnabled(True))
self.machineThread.started.connect(lambda: self.ui.start_machine_button.setDisabled(True))
self.machineThread.started.connect(lambda: self.ui.start_machine_button.setText("running..."))
self.machineThread.started.connect(lambda: self.ui.prev_button.setDisabled(True))
# self.machineThread.finished.connect(lambda: self.ui.start_machine_button.setEnabled(True))
self.machineThread.finished.connect(self.machineThread.start) # repeat thread
self.ui.stop_machine_button.clicked.connect(self.machineThread.stop_machine)
self.ui.stop_machine_button.clicked.connect(lambda: self.machineThread.disconnect(self.machineThread))
self.ui.stop_machine_button.clicked.connect(lambda: self.ui.stop_machine_button.setText("stopping ..."))
self.ui.stop_machine_button.clicked.connect(lambda: self.machineThread.finished.connect(self.machineDone))
self.machineThread.BoltFrame.connect(self.setBoltFrame)
self.machineThread.BoltType.connect(lambda x: self.ui.detected_bolt_type.setText(x))
self.machineThread.BoltCounts.connect(self.updateBoltCounts)
self.machineThread.BoltCounts.connect(self.updateProgress)
def machineDone(self):
self.ui.stop_machine_button.setDisabled(True)
self.ui.stop_machine_button.setText("stopped")
self.ui.start_machine_button.setText("sorted subassembly")
self.ui.next_button.setText("Empty System Check >>")
self.ui.next_button.setEnabled(True)
self.ui.prev_button.setDisabled(True)
def sum_column_table(self, column_no):
# count sum of total on x bus
table = self.ui.tableWidget_2
sum = 0
for i in range(0,table.rowCount()):
item:QTableWidgetItem= table.item(i,column_no)
sum+=int(item.text())
return sum
def setupConnect(self):
self.connectRobotThread = ConnectRobotThread()
self.connectRobotThread.resultReady.connect(lambda x: self.ui.status_robot.setText(x))
self.connectRobotThread.finished.connect(self.connect_finished)
self.connectArduinoThread = ConnectArduinoThread()
self.connectArduinoThread.resultReady.connect(lambda x: self.ui.status_arduino.setText(x))
self.connectArduinoThread.finished.connect(self.connect_finished)
self.connectCameraThread = ConnectCameraThread()
self.connectCameraThread.resultReady.connect(lambda x: self.ui.status_camera.setText(x))
self.connectCameraThread.finished.connect(self.connect_finished)
self.connectCameraThread.deviceConnected.connect(self.th.start)
self.ui.button_connect.clicked.connect(self.connectRobotThread.start)
self.ui.button_connect.clicked.connect(self.connectArduinoThread.start)
self.ui.button_connect.clicked.connect(self.connectCameraThread.start)
self.ui.button_connect.clicked.connect(lambda: self.ui.button_connect.setDisabled(True))
def connect_finished(self):
print("finished")
if self.connectRobotThread.isFinished()\
and self.connectArduinoThread.isFinished()\
and self.connectCameraThread.isFinished(): # all are finished
print('finished')
self.ui.button_connect.setEnabled(True)
if self.connectRobotThread.is_connected\
and self.connectArduinoThread.is_connected\
and self.connectCameraThread.is_connected: # check here if all devices are connected
# delete threads
self.connectRobotThread.deleteLater()
self.connectArduinoThread.deleteLater()
self.connectCameraThread.deleteLater()
self.ui.button_connect.setDisabled(True)
self.ui.button_connect.setText("All devices connected")
self.ui.next_button.setEnabled(True)
def goToNext(self):
index = self.ui.stackedWidget.currentIndex()
new_index = index + 1
if(index == self.page_index['page_machine']):
new_index = self.page_index['page_system_check']
self.ui.stackedWidget.setCurrentIndex(new_index)
def goToPrev(self):
index = self.ui.stackedWidget.currentIndex()
self.ui.stackedWidget.setCurrentIndex(index - 1)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_inicio_button.clicked.connect(self.agregar_ini)
self.ui.agregar_final_button.clicked.connect(self.agregar_fin)
self.ui.mostrar_button.clicked.connect(self.mostrar)
self.ui.actionAbrir.triggered.connect(self.abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.guardar_archivo)
@Slot()
def abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(
self,
"Abrir",
".",
"JSON (*.json)",
)[0]
if self.organizador.abrir(ubicacion):
QMessageBox.information(
self, "Operación Exitosa",
"El archivo se abrió con éxito desde la direccion: \n" +
ubicacion)
else:
QMessageBox.critical(self, "Error!",
"El archivo no se logró abrir")
@Slot()
def guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guadar', '.',
'JSON (*.json)')[0]
if self.organizador.guardar(ubicacion):
QMessageBox.information(
self, "Operación Exitosa",
"El archivo se guardó con éxito en la direccion: \n" +
ubicacion)
else:
QMessageBox.critical(self, "Error!",
"El archivo no se logró guardar")
@Slot()
def agregar_ini(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id, or_x, or_y, ds_x, ds_y, vel, red, grn, blu)
self.organizador.agregar_inicio(part)
@Slot()
def agregar_fin(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id, or_x, or_y, ds_x, ds_y, vel, red, grn, blu)
self.organizador.agregar_final(part)
def mostrar(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(str(self.organizador))
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_inicio_button.clicked.connect(self.agregar_ini)
self.ui.agregar_final_button.clicked.connect(self.agregar_fin)
self.ui.mostrar_button.clicked.connect(self.mostrar)
self.ui.actionAbrir.triggered.connect(self.abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.guardar_archivo)
self.ui.buscar_button.clicked.connect(self.buscar)
self.ui.mostrar_tabla_button.clicked.connect(self.mostrar_tabla)
@Slot()
def buscar(self):
key = int(self.ui.buscar_line_edit.text())
find = False
for particula in self.organizador:
if key == particula.id:
self.ui.tabla.setColumnCount(10)
labels = ['ID','Origen en X','Origen en Y','Destino en X','Destino en Y','Velocidad','Distancia','Red','Green','Blue']
self.ui.tabla.setHorizontalHeaderLabels(labels)
self.ui.tabla.setRowCount(1)
self.ui.tabla.setItem(0, 0, QTableWidgetItem(str(particula.id)))
self.ui.tabla.setItem(0, 1, QTableWidgetItem(str(particula.or_x)))
self.ui.tabla.setItem(0, 2, QTableWidgetItem(str(particula.or_y)))
self.ui.tabla.setItem(0, 3, QTableWidgetItem(str(particula.de_x)))
self.ui.tabla.setItem(0, 4, QTableWidgetItem(str(particula.de_y)))
self.ui.tabla.setItem(0, 5, QTableWidgetItem(str(particula.vel)))
self.ui.tabla.setItem(0, 6, QTableWidgetItem(str(particula.dis)))
self.ui.tabla.setItem(0, 7, QTableWidgetItem(str(particula.red)))
self.ui.tabla.setItem(0, 8, QTableWidgetItem(str(particula.green)))
self.ui.tabla.setItem(0, 9, QTableWidgetItem(str(particula.blue)))
find = True
return
if find == False:
QMessageBox.warning(
self,
"Atención",
f"La partícula '{key}' no fue encontrada"
)
@Slot()
def mostrar_tabla(self):
self.ui.tabla.setColumnCount(10)
labels = ['ID','Origen en X','Origen en Y','Destino en X','Destino en Y','Velocidad','Distancia','Red','Green','Blue']
self.ui.tabla.setHorizontalHeaderLabels(labels)
self.ui.tabla.setRowCount(len(self.organizador))
fila=0
for particula in self.organizador:
self.ui.tabla.setItem(fila, 0, QTableWidgetItem(str(particula.id)))
self.ui.tabla.setItem(fila, 1, QTableWidgetItem(str(particula.or_x)))
self.ui.tabla.setItem(fila, 2, QTableWidgetItem(str(particula.or_y)))
self.ui.tabla.setItem(fila, 3, QTableWidgetItem(str(particula.de_x)))
self.ui.tabla.setItem(fila, 4, QTableWidgetItem(str(particula.de_y)))
self.ui.tabla.setItem(fila, 5, QTableWidgetItem(str(particula.vel)))
self.ui.tabla.setItem(fila, 6, QTableWidgetItem(str(particula.dis)))
self.ui.tabla.setItem(fila, 7, QTableWidgetItem(str(particula.red)))
self.ui.tabla.setItem(fila, 8, QTableWidgetItem(str(particula.green)))
self.ui.tabla.setItem(fila, 9, QTableWidgetItem(str(particula.blue)))
fila += 1
@Slot()
def abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(
self,
"Abrir",
".",
"JSON (*.json)",
)[0]
if self.organizador.abrir(ubicacion):
QMessageBox.information(
self,
"Operación Exitosa",
"El archivo se abrió con éxito desde la direccion: \n" + ubicacion
)
else:
QMessageBox.critical(
self,
"Error!",
"El archivo no se logró abrir"
)
@Slot()
def guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(self,
'Guadar',
'.',
'JSON (*.json)')[0]
if self.organizador.guardar(ubicacion):
QMessageBox.information(
self,
"Operación Exitosa",
"El archivo se guardó con éxito en la direccion: \n" + ubicacion
)
else:
QMessageBox.critical(
self,
"Error!",
"El archivo no se logró guardar"
)
@Slot()
def agregar_ini(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id,or_x,or_y,ds_x,ds_y,vel,red,grn,blu)
self.organizador.agregar_inicio(part)
@Slot()
def agregar_fin(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id,or_x,or_y,ds_x,ds_y,vel,red,grn,blu)
self.organizador.agregar_final(part)
def mostrar(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(str(self.organizador))
class MainWindow(QMainWindow):
episode_data = {"labels": []}
current_index = 0
highest_index = 0
listened = [False, False, False]
moods = import_export.schema["properties"]["labels"]["items"][
"properties"]["mood"]["items"]["enum"]
isUpdatingWidgets = False
unsavedChanges = False
# Sets up the main window
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.moodbox.addItems(self.moods)
self.update_title(False)
self.ui.all_buttons.setEnabled(False)
# Dropdown events
self.ui.actionLoad_episode.triggered.connect(self.load_episode)
self.ui.actionSave_changes.triggered.connect(self.save_changes)
self.ui.actionAdd_audio_path.triggered.connect(self.add_audio_path)
self.ui.actionGenerate_Audacity_labels.triggered.connect(
lambda: self.export_to_labels(None))
self.ui.actionExport_dataset.triggered.connect(self.export_dataset)
self.ui.actionGenerate_Audacity_labels_all_episodes.triggered.connect(
lambda: self.export_all_labels(None))
# Previous/next events
self.ui.button_next.clicked.connect(lambda: self.next_label(False))
self.ui.button_previous.clicked.connect(lambda: self.next_label(True))
# Listen/choose events
self.ui.button_listenorig.clicked.connect(
lambda: self.listen_to_source(0))
self.ui.button_listenizo.clicked.connect(
lambda: self.listen_to_source(1))
self.ui.button_listenunmix.clicked.connect(
lambda: self.listen_to_source(2))
self.ui.button_chooseorig.clicked.connect(
lambda: self.choose_source(0))
self.ui.button_chooseizo.clicked.connect(lambda: self.choose_source(1))
self.ui.button_chooseunmix.clicked.connect(
lambda: self.choose_source(2))
# Other events
self.ui.startbox.valueChanged.connect(lambda: self.update_title(True))
self.ui.endbox.valueChanged.connect(lambda: self.update_title(True))
self.ui.characterbox.textChanged.connect(
lambda: self.update_title(True))
self.ui.moodbox.currentIndexChanged.connect(
lambda: self.update_title(True))
self.ui.transcriptbox.textChanged.connect(
lambda: self.update_title(True))
self.ui.radio_clean.clicked.connect(lambda: self.update_title(True))
self.ui.radio_noisy.clicked.connect(lambda: self.update_title(True))
self.ui.radio_verynoisy.clicked.connect(
lambda: self.update_title(True))
# End of events
self.scan_for_files()
# Updates the large text box at the bottom of the window
def console(self, message):
self.ui.consolebox.setText(self.ui.consolebox.toPlainText() + message +
"\n")
self.ui.consolebox.moveCursor(QTextCursor.End)
# Updates the window title to show unsaved changes
def update_title(self, isChanged=True):
if isChanged:
if not self.isUpdatingWidgets:
self.setWindowTitle("Pony Sorter *")
self.unsavedChanges = True
else:
self.setWindowTitle("Pony Sorter")
self.unsavedChanges = False
# Updates the widget contents with the info stored in episode_data
def update_widgets(self, index):
# Label data
self.isUpdatingWidgets = True
l = self.episode_data["labels"][index]
self.ui.startbox.setValue(l["start"])
self.ui.endbox.setValue(l["end"])
self.ui.characterbox.setText(l["character"])
self.ui.transcriptbox.setText(l["transcript"])
self.ui.moodbox.setCurrentIndex(self.moods.index(l["mood"][0]))
if len(l["mood"]) > 1:
self.ui.secondarymoodlabel.setText(l["mood"][1] + " (secondary)")
else:
self.ui.secondarymoodlabel.setText("none (secondary)")
if l["noise_level"] == "clean":
self.ui.radio_clean.setChecked(True)
elif l["noise_level"] == "noisy":
self.ui.radio_noisy.setChecked(True)
elif l["noise_level"] == "verynoisy":
self.ui.radio_verynoisy.setChecked(True)
self.isUpdatingWidgets = False
# Navigation
self.ui.all_buttons.setEnabled(True)
self.listened = [l["reviewed"], l["reviewed"], l["reviewed"]]
self.toggle_choices()
if index >= len(self.episode_data["labels"]) - 1:
self.ui.button_next.setEnabled(False)
else:
self.ui.button_next.setEnabled(l["reviewed"])
if index <= 0:
self.ui.button_previous.setEnabled(False)
else:
self.ui.button_previous.setEnabled(True)
# Play audio from selected source
def listen_to_source(self, index):
self.update_dictionary()
def play_audio(source, start, end):
source.set(AL_SEC_OFFSET, start)
source.play()
time.sleep(end - start)
source.stop()
l = self.episode_data["labels"][self.current_index]
if index == 0:
play_audio(self.source1, l["start"], l["end"])
elif index == 1:
play_audio(self.source2, l["start"], l["end"])
elif index == 2:
play_audio(self.source3, l["start"], l["end"])
self.listened[index] = True
self.toggle_choices()
def choose_source(self, index):
l = self.episode_data["labels"][self.current_index]
if index == 0:
l["ideal_source"] = "original"
elif index == 1:
l["ideal_source"] = "izo"
elif index == 2:
l["ideal_source"] = "unmix"
l["reviewed"] = True
self.update_title(True)
self.next_label(False)
# Enables/disables the choice buttons
def toggle_choices(self):
if self.listened[0] == True and self.listened[1] == True:
self.ui.button_chooseorig.setEnabled(True)
self.ui.button_chooseizo.setEnabled(True)
# self.ui.button_chooseunmix.setEnabled(True)
else:
self.ui.button_chooseorig.setEnabled(False)
self.ui.button_chooseizo.setEnabled(False)
# self.ui.button_chooseunmix.setEnabled(False)
# Writes the modified widget contents back to episode_data
def update_dictionary(self):
l = self.episode_data["labels"][self.current_index]
l["start"] = self.ui.startbox.value()
l["end"] = self.ui.endbox.value()
l["character"] = self.ui.characterbox.text()
l["transcript"] = self.ui.transcriptbox.text()
if l["mood"][0] in self.moods:
l["mood"][0] = self.moods[self.ui.moodbox.currentIndex()]
if self.ui.radio_clean.isChecked():
l["noise_level"] = "clean"
elif self.ui.radio_noisy.isChecked():
l["noise_level"] = "noisy"
elif self.ui.radio_verynoisy.isChecked():
l["noise_level"] = "verynoisy"
# Goes to the next/previous label
def next_label(self, isBackwards=False):
if isBackwards:
new_index = self.current_index - 1
else:
new_index = self.current_index + 1
if new_index < 0:
return False
if new_index > len(self.episode_data["labels"]) - 1:
message = "All done! Please save your changes and load a new episode."
endOfFile = QMessageBox()
endOfFile.setText(message)
endOfFile.exec_()
self.console(message)
return False
self.update_dictionary()
self.current_index = new_index
self.update_widgets(new_index)
return True
# Load a new episode
def load_episode(self):
if self.unsavedChanges:
changesAsk = QMessageBox.question(
self,
"Save changes?",
"Save changes before loading new episode?",
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel,
)
if changesAsk == QMessageBox.Cancel:
return
if changesAsk == QMessageBox.Yes:
self.save_changes()
self.dialog = LoadDialog()
self.dialog.exec_()
if not self.dialog.okay:
return
self.episode_data = self.dialog.episode_data
self.update_title(False)
first_unreviewed = 0
for i, l in enumerate(self.episode_data["labels"]):
if l["reviewed"] == False:
first_unreviewed = i
break
self.current_index = first_unreviewed
self.highest_index = first_unreviewed
self.update_widgets(first_unreviewed)
self.load_audio()
self.ui.actionSave_changes.setEnabled(True)
# Load audio files. Converts to Ogg Vorbis first; OpenAL plays some FLAC files as loud static
# Crashes occasionally with "double free or corruption (out)" or "corrupted size vs. prev_size"
def load_audio(self):
def convert_to_ogg(inpath, outname):
outpath = (os.path.dirname(os.path.realpath(__file__)) + "/" +
outname + ".ogg")
ffmpeg.input(inpath).output(outpath).overwrite_output().run()
return outpath
self.ui.all_buttons.setEnabled(False)
original_path, izo_path, unmix_path = import_export.find_audio_path(
self.episode_data["label_name"])
if original_path == "":
self.console("Error: Original audio not found")
self.source1 = None
else:
self.console("Loading original audio from " + original_path +
"...")
QApplication.processEvents()
self.source1 = oalOpen(convert_to_ogg(original_path, ".temp1"))
if izo_path == "":
self.console("Error: iZo audio not found")
self.source2 = None
else:
self.console("Loading iZo audio from " + izo_path + "...")
QApplication.processEvents()
self.source2 = oalOpen(convert_to_ogg(izo_path, ".temp2"))
"""if unmix_path == "":
self.console("Error: iZo+Unmix audio not found")
self.source3 = None
else:
self.console("Loading iZo+Unmix audio from " + unmix_path + "...")
QApplication.processEvents()
self.source3 = oalOpen(convert_to_ogg(unmix_path, ".temp3"))"""
self.console("\nLoading complete!")
self.ui.all_buttons.setEnabled(True)
# Save episode_data to JSON file
def save_changes(self):
self.update_dictionary()
self.episode_data["last_modified"] = datetime.datetime.utcnow(
).isoformat()
self.update_title(False)
path = import_export.export_to_json(self.episode_data)
self.console("Saved changes to " + path)
# Save episode_data to Audacity labels
def export_to_labels(self, character=None):
self.update_dictionary()
self.episode_data["last_modified"] = datetime.datetime.utcnow(
).isoformat()
import_export.export_to_labels(self.episode_data, character,
"original")
import_export.export_to_labels(self.episode_data, character, "izo")
import_export.export_to_labels(self.episode_data, character, "unmix")
path = import_export.export_to_labels(self.episode_data, character,
None)
self.console("Exported labels to " + path)
# Export all saved episodes to Audacity labels
def export_all_labels(self, character=None):
for k, _ in hashes.friendly_names.items():
path1 = (os.path.dirname(os.path.realpath(__file__)) +
"/saved_changes/" + k + ".json")
path2 = (os.path.dirname(os.path.realpath(__file__)) + "/labels/" +
k + ".txt")
if os.path.exists(path1):
export_data = import_export.import_from_json(path1)
elif os.path.exists(path2):
export_data = import_export.import_from_labels(path2)
else:
continue
import_export.export_to_labels(export_data, character, "original")
import_export.export_to_labels(export_data, character, "izo")
import_export.export_to_labels(export_data, character, "unmix")
import_export.export_to_labels(export_data, character, None)
self.console("Exported all labels to " +
os.path.dirname(os.path.realpath(__file__)) +
"/exported_labels/")
# (UNUSED) Splits audio samples and generates LJ Speech metadata
def split_by_pony(self, character=None):
metadata = []
for k, _ in hashes.friendly_names.items():
path1 = (os.path.dirname(os.path.realpath(__file__)) +
"/saved_changes/" + k + ".json")
path2 = (os.path.dirname(os.path.realpath(__file__)) + "/labels/" +
k + ".txt")
if os.path.exists(path1):
export_data = import_export.import_from_json(path1)
elif os.path.exists(path2):
export_data = import_export.import_from_labels(path2)
else:
continue
self.console("Exporting from " + export_data["label_name"] + "...")
QApplication.processEvents()
metadata.extend(
import_export.split_by_pony(export_data, character,
self.moods))
with open(
os.path.dirname(os.path.realpath(__file__)) +
"/exported_clips/transcripts.csv",
"w",
) as f:
for m in metadata:
f.write(m + "\n")
self.console("Done! Exported all " + character + " splits to " +
os.path.dirname(os.path.realpath(__file__)) +
"/exported_clips/")
# Opens export dialog
def export_dataset(self):
if self.unsavedChanges:
changesAsk = QMessageBox.question(
self,
"Save changes?",
"Save changes before exporting dataset?",
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel,
)
if changesAsk == QMessageBox.Cancel:
return
if changesAsk == QMessageBox.Yes:
self.save_changes()
self.dialog = ExportDialog()
self.dialog.exec_()
if not self.dialog.okay:
return
self.console("Export dummy message")
return
# Update the paths where the audio files are stored
def add_audio_path(self):
new_paths, okay = QInputDialog.getMultiLineText(
self,
"Add audio path(s)",
"Enter the directories where the audio files are stored, separated by line breaks. Sub-directories will be scanned automatically.",
"\n".join(import_export.config["audio_paths"]),
)
if okay:
import_export.config["audio_paths"] = new_paths.splitlines()
path = import_export.write_config()
self.console("Saved settings to " + path)
self.scan_for_files()
# Find and hash audio files; takes about 5 minutes the first time
def scan_for_files(self):
self.ui.actionLoad_episode.setEnabled(False)
self.ui.actionAdd_audio_path.setEnabled(False)
self.timer = QTimer()
self.timer.setInterval(100)
self.timer.timeout.connect(self.hash_update)
self.queue = queue.Queue()
hash_thread = threading.Thread(target=import_export.hash_audio_files,
args=(self.queue, ))
hash_thread.daemon = True
hash_thread.start()
self.timer.start()
# Check if hashes have finished computing
def hash_update(self):
while not self.queue.empty():
data = self.queue.get()
if data == "msgdone":
self.timer.stop()
self.ui.actionLoad_episode.setEnabled(True)
self.ui.actionAdd_audio_path.setEnabled(True)
else:
self.console(data)
class main_window(QtWidgets.QMainWindow):
@QtCore.pyqtSlot("QString")
def receive_error(self,error):
self.show_error(error)
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.compile_btn.clicked.connect(self.compile_btn_clicked)
self.ui.test_btn.clicked.connect(self.test_btn_clicked)
def compile_btn_clicked(self):
self.regex2nfa_obj=regex2nfa(self.ui.regex_line_edit.text())
self.regex2nfa_obj.send_error.connect(self.receive_error)
self.regex2nfa_obj.convert_to_nfa()
nfa=self.regex2nfa_obj.nfa
automata.display_nx_automata(nfa, "nfa", "NFA")
nfa2dfa_obj = nfa2dfa('nfa2dfa')
nfa2dfa_obj.set_nfa(nfa)
nfa2dfa_obj.set_charset(nfa.char_set)
nfa2dfa_obj.build_dfa()
aut_dfa = nfa2dfa_obj.dfa
nfa2dfa_obj.display_automata()
automata.display_nx_automata(aut_dfa, "dfa", "DFA")
dfa2mindfa_obj = dfa2mindfa(aut_dfa)
dfa2mindfa_obj.minimiseIt()
self.min_dfa = automata("min_dfa")
self.min_dfa = dfa2mindfa_obj.create_new_dfa()
self.min_dfa.display_automata()
automata.display_nx_automata(self.min_dfa, "min_dfa", "MINIMAL DFA")
self.show_graph()
def test_btn_clicked(self):
result=self.min_dfa.accepting_string(self.ui.test_line_edit.text())
if result:
self.ui.test_result_line_edit.setText("Accepted")
else:
self.ui.test_result_line_edit.setText("Rejected")
def show_error(self,error):
QtWidgets.QMessageBox.critical(self,"Error",error)
def show_graph(self):
self.nfa_scene=QtWidgets.QGraphicsScene(self)
self.dfa_scene=QtWidgets.QGraphicsScene(self)
self.min_dfa_scene=QtWidgets.QGraphicsScene(self)
nfa_pic = QtGui.QPixmap.fromImage(QtGui.QImage("pics/nfa.png"))
self.nfa_scene.addPixmap(nfa_pic)
self.ui.nfa_graphic_view.setScene(self.nfa_scene)
dfa_pic = QtGui.QPixmap.fromImage(QtGui.QImage("pics/dfa.png"))
self.dfa_scene.addPixmap(dfa_pic)
self.ui.dfa_graphic_view.setScene(self.dfa_scene)
min_dfa_pic = QtGui.QPixmap.fromImage(QtGui.QImage("pics/min_dfa.png"))
self.min_dfa_scene.addPixmap(min_dfa_pic)
self.ui.min_dfa_graphic_view.setScene(self.min_dfa_scene)
def __init__(self, app):
QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.setWindowTitle("BlobBackup")
self.setWindowIcon(QIcon(get_resource_path("images/logo.ico")))
self.app = app
self.threads = {}
self.thread = None
self.log_text_edit.setMaximumBlockCount(500)
self.log_text_edit.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
self.log_file_thread = LogFileThread()
self.log_file_thread.start()
self.log_file_thread.updated.connect(self.add_log)
self.full_log_button.pressed.connect(self.open_log_file)
self.show_everything_radio_button.toggled.connect(
self.log_text_edit.clear)
self.only_errors_radio_button.toggled.connect(
lambda: self.update_logs(force=True))
self.backups_tree_widget.itemClicked.connect(self.update_logs)
self.tool_bar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.tool_bar.setIconSize(QSize(10, 10))
self.go_action.setIcon(QIcon(get_resource_path("images/go.png")))
self.stop_action.setIcon(QIcon(get_resource_path("images/stop.png")))
self.view_action.setIcon(QIcon(get_resource_path("images/view.png")))
self.delete_action.setIcon(
QIcon(get_resource_path("images/delete.png")))
self.edit_action.setIcon(QIcon(get_resource_path("images/edit.png")))
self.add_new_backup_action.triggered.connect(self.add_new_backup)
self.connect_to_existing_backup_action.triggered.connect(
self.connect_backup)
self.delete_action.triggered.connect(self.delete_backup)
self.edit_action.triggered.connect(self.edit_backup)
self.backups_tree_widget.itemDoubleClicked.connect(self.edit_backup)
self.go_action.triggered.connect(self.go_backup)
self.stop_action.triggered.connect(self.stop_backup)
self.view_action.triggered.connect(self.view_backup)
self.exit_action.triggered.connect(self.exit)
self.backups_tree_widget.itemClicked.connect(self.set_go_action)
self.website_action.triggered.connect(
lambda: webbrowser.open("https://blobbackup.com/docs.php"))
self.run_all_action.triggered.connect(lambda: self.run_all(None))
self.run_local_action.triggered.connect(
lambda: self.run_all("Local Directory"))
self.run_aws_action.triggered.connect(
lambda: self.run_all("Amazon AWS"))
self.run_gcp_action.triggered.connect(
lambda: self.run_all("Google Cloud"))
self.run_azure_action.triggered.connect(
lambda: self.run_all("Microsoft Azure"))
self.run_b2_action.triggered.connect(
lambda: self.run_all("Backblaze B2"))
self.run_s3_action.triggered.connect(
lambda: self.run_all("S3 Storage"))
self.run_sftp_only.triggered.connect(lambda: self.run_all("SFTP"))
self.add_one_to_start_button.pressed.connect(
self.add_new_backup_action.trigger)
self.populate()
class MainWindow(QtGui.QMainWindow):
show_status = QtCore.pyqtSignal(bool, str)
def __init__(self, sysbus, parent=None):
QtGui.QWidget.__init__(self, parent)
# Init ourself from the Designer UI
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# light up the admin interface
self.admin = AdminInterface(SERVICE,
'/org/ganesha/nfsd/admin',
sysbus,
self.show_status)
self.exportmgr = ExportMgr(SERVICE,
'/org/ganesha/nfsd/ExportMgr',
sysbus,
self.show_status)
self.clientmgr = ClientMgr(SERVICE,
'/org/ganesha/nfsd/ClientMgr',
sysbus,
self.show_status)
self.logmanager = LogManager(SERVICE,
sysbus,
self.show_status)
self.logdialog = LogSetDialog(self.logmanager)
self.show_status.connect(self.status_message)
# Connect up the ui menubar
#File
self.ui.actionDBus_connect.triggered.connect(self.connect_gsh)
self.ui.actionQuit.triggered.connect(self.quit)
#Manage
#Manage->Clients
self.ui.actionAdd_Client.triggered.connect(self.add_client)
self.ui.actionRemove_Client.triggered.connect(self.remove_client)
#Manage->Exports
self.ui.actionExports.triggered.connect(self.export_mgr)
#Manage->Log Levels
self.ui.actionLog_Settings.triggered.connect(self.logsettings)
#Manage->Admin
self.ui.actionReset_Grace.triggered.connect(self.reset_grace)
self.ui.actionShutdown.triggered.connect(self.shutdown)
self.ui.actionReload.triggered.connect(self.reload)
#View
self.ui.actionStatistics.triggered.connect(self.stats)
self.ui.actionViewExports.triggered.connect(self.view_exports)
self.ui.actionViewClients.triggered.connect(self.view_clients)
#Help
self.ui.actionAbout.triggered.connect(self.help)
# Dbus data models
self.exports_show_model = ExportTableModel(self.exportmgr)
self.clients_show_model = ClientTableModel(self.clientmgr)
# Tabs, tables, and views
self.ui.exports.setModel(self.exports_show_model)
self.ui.exports.resizeColumnsToContents()
self.ui.exports.verticalHeader().setVisible(False)
self.ui.clients.setModel(self.clients_show_model)
self.ui.clients.resizeColumnsToContents()
self.ui.clients.verticalHeader().setVisible(False)
# actions to real work...
def quit(self):
self.statusBar().showMessage("Bye bye kiddies, quitting")
quit()
def connect_gsh(self):
self.statusBar().showMessage("Connecting to nfs-ganesha...")
def add_client(self):
ipaddr, ok = QtGui.QInputDialog.getText(self,
'Add a Client',
'IP Address (N.N.N.N) of client: ')
if ok:
self.clientmgr.AddClient(ipaddr)
def remove_client(self):
ipaddr, ok = QtGui.QInputDialog.getText(self,
'Remove a Client',
'IP Address (N.N.N.N) of client: ')
if ok:
self.clientmgr.RemoveClient(ipaddr)
def export_mgr(self):
self.statusBar().showMessage("Export manager")
def logsettings(self):
self.logdialog.show_logsetting_dialog()
def reset_grace(self):
ipaddr, ok = QtGui.QInputDialog.getText(self,
'Grace Period',
'IP Address (N.N.N.N) of client: ')
if ok:
self.admin.grace(ipaddr)
def shutdown(self):
reply = QtGui.QMessageBox.question(self,
'Warning!!!',
"Do you really want to shut down the server?",
QtGui.QMessageBox.Yes |
QtGui.QMessageBox.No,
QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
self.admin.shutdown()
def reload(self):
reply = QtGui.QMessageBox.question(self,
'Warning!!!',
"Do you really want to reload exports?",
QtGui.QMessageBox.Yes |
QtGui.QMessageBox.No,
QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
self.admin.reload()
def stats(self):
self.statusBar().showMessage("stats go here")
def view_exports(self):
self.exports_show_model.FetchExports()
def view_clients(self):
self.clients_show_model.FetchClients()
def help(self):
self.statusBar().showMessage("Help! Help!!")
def status_message(self, status, errormsg):
if status:
str = "Success: "
else:
str = "Failed: "
self.statusBar().showMessage(str + errormsg)
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.compile_btn.clicked.connect(self.compile_btn_clicked)
self.ui.test_btn.clicked.connect(self.test_btn_clicked)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.scene = QGraphicsScene()
self.ui.graficos.setScene(self.scene)
self.ui.agregar_inicio_button.clicked.connect(self.agregar_ini)
self.ui.agregar_final_button.clicked.connect(self.agregar_fin)
self.ui.mostrar_button.clicked.connect(self.mostrar)
self.ui.buscar_button.clicked.connect(self.buscar)
self.ui.mostrar_tabla_button.clicked.connect(self.mostrar_tabla)
self.ui.dibujar_button.clicked.connect(self.dibujar)
self.ui.limpiar_button.clicked.connect(self.limpiar)
self.ui.generar_button.clicked.connect(self.generar)
self.ui.actionAbrir.triggered.connect(self.abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.guardar_archivo)
self.ui.actionGrafo.triggered.connect(self.generar_grafo)
self.ui.actionRecorrido.triggered.connect(self.recorrido)
self.ui.id_checkbox.stateChanged.connect(self.ordenar_id)
self.ui.velocidad_checkbox.stateChanged.connect(self.ordenar_vel)
self.ui.distancia_checkbox.stateChanged.connect(self.ordenar_dis)
def recorrido(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText("Recorrido en Profundidad: \n")
self.ui.plainTextEdit.insertPlainText(
self.organizador.profundidad(self.ui.origen_X.value(),
self.ui.origen_y.value()))
self.ui.plainTextEdit.insertPlainText("\n\nRecorrido en Amplitud: \n")
self.ui.plainTextEdit.insertPlainText(
self.organizador.amplitud(self.ui.origen_X.value(),
self.ui.origen_y.value()))
def generar_grafo(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(
"Grafo (Lista de Adyacencia): \n")
self.ui.plainTextEdit.insertPlainText(self.organizador.grafo())
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graficos.scale(1.1, 1.1)
else:
self.ui.graficos.scale(0.9, 0.9)
@Slot()
def ordenar_id(self):
if self.ui.id_checkbox.isChecked():
self.ui.velocidad_checkbox.setChecked(False)
self.ui.distancia_checkbox.setChecked(False)
self.organizador.orden(False, "id")
@Slot()
def ordenar_dis(self):
if self.ui.distancia_checkbox.isChecked():
self.ui.velocidad_checkbox.setChecked(False)
self.ui.id_checkbox.setChecked(False)
self.organizador.orden(True, "dis")
@Slot()
def ordenar_vel(self):
if self.ui.velocidad_checkbox.isChecked():
self.ui.distancia_checkbox.setChecked(False)
self.ui.id_checkbox.setChecked(False)
self.organizador.orden(False, "vel")
@Slot()
def dibujar(self):
pen = QPen()
brush = QBrush()
pen.setWidth(3)
for i in self.organizador:
color = QColor(i.red, i.green, i.blue)
brush.setStyle(Qt.SolidPattern)
brush.setColor(color)
pen.setColor(color)
self.scene.addEllipse(i.or_x, i.or_y, 7, 7, pen, brush)
self.scene.addEllipse(i.de_x, i.de_y, 7, 7, pen, brush)
self.scene.addLine((i.or_x) + 3.5, (i.or_y) + 3.5, (i.de_x) + 3.5,
(i.de_y) + 3.5, pen)
for keys in self.organizador.grafo_dic:
text = QGraphicsTextItem(str(keys))
text.setFlag(QGraphicsItem.ItemIsMovable)
text.setFont(QFont("TimesNewRoman", 12, QFont.ExtraBold))
self.scene.addItem(text)
text.setPos(keys[0], keys[1])
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def generar(self):
self.ui.id.setValue((randint(0, 9) * 10000) + (randint(0, 9) * 1000) +
(randint(0, 9) * 100) + (randint(0, 9) * 10) +
randint(0, 9))
self.ui.origen_X.setValue(randint(0, 500))
self.ui.origen_y.setValue(randint(0, 500))
self.ui.destino_x.setValue(randint(0, 500))
self.ui.destino_y.setValue(randint(0, 500))
self.ui.vel.setValue(randint(0, 200))
self.ui.red.setValue(randint(0, 255))
self.ui.green.setValue(randint(0, 255))
self.ui.blue.setValue(randint(0, 225))
@Slot()
def buscar(self):
key = int(self.ui.buscar_line_edit.text())
find = False
for particula in self.organizador:
if key == particula.id:
self.ui.tabla.setColumnCount(10)
labels = [
'ID', 'Origen en X', 'Origen en Y', 'Destino en X',
'Destino en Y', 'Velocidad', 'Distancia', 'Red', 'Green',
'Blue'
]
self.ui.tabla.setHorizontalHeaderLabels(labels)
self.ui.tabla.setRowCount(1)
self.ui.tabla.setItem(0, 0,
QTableWidgetItem(str(particula.id)))
self.ui.tabla.setItem(0, 1,
QTableWidgetItem(str(particula.or_x)))
self.ui.tabla.setItem(0, 2,
QTableWidgetItem(str(particula.or_y)))
self.ui.tabla.setItem(0, 3,
QTableWidgetItem(str(particula.de_x)))
self.ui.tabla.setItem(0, 4,
QTableWidgetItem(str(particula.de_y)))
self.ui.tabla.setItem(0, 5,
QTableWidgetItem(str(particula.vel)))
self.ui.tabla.setItem(0, 6,
QTableWidgetItem(str(particula.dis)))
self.ui.tabla.setItem(0, 7,
QTableWidgetItem(str(particula.red)))
self.ui.tabla.setItem(0, 8,
QTableWidgetItem(str(particula.green)))
self.ui.tabla.setItem(0, 9,
QTableWidgetItem(str(particula.blue)))
find = True
return
if find == False:
QMessageBox.warning(self, "Atención",
f"La partícula '{key}' no fue encontrada")
@Slot()
def mostrar_tabla(self):
self.ui.tabla.setColumnCount(10)
labels = [
'ID', 'Origen en X', 'Origen en Y', 'Destino en X', 'Destino en Y',
'Velocidad', 'Distancia', 'Red', 'Green', 'Blue'
]
self.ui.tabla.setHorizontalHeaderLabels(labels)
self.ui.tabla.setRowCount(len(self.organizador))
fila = 0
for particula in self.organizador:
self.ui.tabla.setItem(fila, 0, QTableWidgetItem(str(particula.id)))
self.ui.tabla.setItem(fila, 1,
QTableWidgetItem(str(particula.or_x)))
self.ui.tabla.setItem(fila, 2,
QTableWidgetItem(str(particula.or_y)))
self.ui.tabla.setItem(fila, 3,
QTableWidgetItem(str(particula.de_x)))
self.ui.tabla.setItem(fila, 4,
QTableWidgetItem(str(particula.de_y)))
self.ui.tabla.setItem(fila, 5,
QTableWidgetItem(str(particula.vel)))
self.ui.tabla.setItem(fila, 6,
QTableWidgetItem(str(particula.dis)))
self.ui.tabla.setItem(fila, 7,
QTableWidgetItem(str(particula.red)))
self.ui.tabla.setItem(fila, 8,
QTableWidgetItem(str(particula.green)))
self.ui.tabla.setItem(fila, 9,
QTableWidgetItem(str(particula.blue)))
fila += 1
@Slot()
def abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(
self,
"Abrir",
".",
"JSON (*.json)",
)[0]
if self.organizador.abrir(ubicacion):
QMessageBox.information(
self, "Operación Exitosa",
"El archivo se abrió con éxito desde la direccion: \n" +
ubicacion)
self.organizador.borrar_grafo()
else:
QMessageBox.critical(self, "Error!",
"El archivo no se logró abrir")
@Slot()
def guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guadar', '.',
'JSON (*.json)')[0]
if self.organizador.guardar(ubicacion):
QMessageBox.information(
self, "Operación Exitosa",
"El archivo se guardó con éxito en la direccion: \n" +
ubicacion)
else:
QMessageBox.critical(self, "Error!",
"El archivo no se logró guardar")
@Slot()
def agregar_ini(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id, or_x, or_y, ds_x, ds_y, vel, red, grn, blu)
self.organizador.agregar_inicio(part)
@Slot()
def agregar_fin(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id, or_x, or_y, ds_x, ds_y, vel, red, grn, blu)
self.organizador.agregar_final(part)
def mostrar(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(str(self.organizador))
class MainWindow(QMainWindow):
progressSignal = pyqtSignal(int)
def __init__(self, parent = None):
QMainWindow.__init__(self, parent)
self.data = None
self.image = None
self.printer = Printer(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setActions()
self.loadSettings()
self.setState(STATE_INIT)
def setState(self, state):
#if state == STATE_INIT:
#self.ui.actionBuild.setEnabled(False)
#elif state == STATE_LOADED:
#self.ui.actionBuild.setEnabled(True)
self.state = state
def setActions(self):
self.ui.actionFileOpen.triggered.connect(self.fileOpen)
self.ui.actionBuild.triggered.connect(self.build)
self.ui.tbConnect.toggled.connect(self.connect_a)
def fileOpen(self):
fileDialog = QFileDialog(self, self.tr('Open file'))
fileDialog.setNameFilters([self.tr('Gerber (*.gbr)'),
self.tr('Image (*.png *.bmp *.jpg)')])
if not fileDialog.exec_():
return
filename = fileDialog.selectedFiles()[0]
fileDialog = OpenFileDialog(filename, self)
if fileDialog.exec_():
self.image = fileDialog.image()
self.ui.view.setPixmap(QPixmap.fromImage(self.image))
self.setState(STATE_LOADED)
def build(self):
self.progress = QProgressDialog(self) #.tr('Building'), self.tr('Cancel'))
self.progress.setRange(0, 100)
self.progressSignal.connect(self.progress.setValue)
self._build(thr_start = True)
self.progress.exec_()
@SimpleThread
def _build(self):
self.updateProgress(10, thr_method = 'q')
pixChunks = getPixelChunks(self.image)
self.updateProgress(20, thr_method = 'q')
w = self.image.width()
h = self.image.height()
res = get_gcode(pixChunks, w, h)
self.updateProgress(30, thr_method = 'q')
t = 0
fres = []
for gcode, pix, t1 in res:
#print t1, pix, gcode
fres.append(gcode)
t+= t1
print h*0.05, w*0.05, t
fres = '\n'.join(fres)
f = open('res.gcode', 'w')
f.write(fres)
f.close()
self.updateProgress(100, thr_method = 'q')
def updateProgress(self, val):
self.progressSignal.emit(val)
def saveSettings(self):
ssv('main_window_geometry', self.saveGeometry())
ssv('main_window_state', self.saveState())
self.saveUiValues()
#self.saveDsbValue('Resolution')
#self.saveDsbValue('PretensioningX')
#self.saveDsbValue('PretensioningY')
def loadSettings(self):
if not self.restoreGeometry(sld('main_window_geometry').toByteArray()): #FIXME
geometry = QRect(0, 0, 800, 600)
geometry.moveCenter(QApplication.desktop().screenGeometry(self).center())
self.setGeometry(geometry)
self.restoreState(sld('main_window_state').toByteArray())
self.loadUiValues()
#self.loadDsbValue('Resolution', 0.1)
#self.loadDsbValue('PretensioningX', 1)
#self.loadDsbValue('PretensioningY', 1)
def loadUiValues(self):
for key, obj in self.ui.__dict__.items():
ok = False
val = sld(key)
if val.isNull():
continue
if type(obj) == QDoubleSpinBox:
val, ok = val.toFloat()
elif type(obj) == QSpinBox:
val, ok = val.toInt()
elif type(obj) == QLineEdit:
val = val.toString()
obj.setText(val)
continue
if ok:
obj.setValue(val)
def saveUiValues(self):
for key, obj in self.ui.__dict__.items():
if type(obj) in (QDoubleSpinBox, QSpinBox):
val = obj.value()
elif type(obj) == QLineEdit:
val = obj.text()
else:
continue
ssv(key, val)
def connect_a(self, con):
if con:
port = self.ui.lePrinterPort.text()
baudrate = self.ui.sbPrinterBaudrate.value()
if not port.isEmpty() and baudrate > 0:
if not self.printer.connect_(port, baudrate):
self.ui.tbConnect.setChecked(False)
else:
self.printer.disconnect_()
def closeEvent(self, event):
self.saveSettings()
