class MainWindow(QMainWindow):
def __init__(self, app, translator, parent=None):
super(MainWindow, self).__init__(parent)
self._app = app
self._translator = translator
app.installTranslator(translator)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self._setup_ui()
def _setup_ui(self):
self._hioki_tab = HiokiTab(self.ui.tab)
self._agilent_tab = AgilentTab(self.ui.tab_2)
self._normal_tab = NormalTab(self.ui.tab_3)
def openFile(self):
'''
print(__file__) # /Users/kakalin/csv/gui/mainwindow.py
print (os.path.dirname(__file__)) # /Users/kakalin/csv/gui
print (os.path.abspath(__file__)) # /Users/kakalin/csv/gui/mainwindow.py
print (os.path.abspath(os.path.dirname(__file__))) # /Users/kakalin/csv/gui
print (os.path.dirname(os.path.abspath(__file__))) # /Users/kakalin/csv/gui
'''
dir = os.path.dirname(__file__)
file_name = QFileDialog.getOpenFileName(self, 'Open file', dir)
print(file_name)
def __init__ (self, app, translator, parent=None):
super(MainWindow, self).__init__(parent)
self._app = app
self._translator = translator
app.installTranslator(translator)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self._setup_ui()
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.cc = ConfigurationController(self)
self.gc = GameController(self.cc, self.updateTable)
self.createConnections()
header = self.ui.tableWidget.horizontalHeader()
header.setSectionResizeMode(QHeaderView.Stretch)
header = self.ui.tableWidget.verticalHeader()
header.setSectionResizeMode(QHeaderView.Stretch)
self.imgImp = ImageImports()
self.ui.logoLabel.setPixmap(
QtGui.QPixmap(self.imgImp.logo).scaledToHeight(200))
self.updateTable()
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.connectActions()
self.loopProcessor = loopLoader.loopLoader()
self.logProcessor = logProcessing.logProcess()
self.runProcessor = Runner.allanandPlots()
self.filename = None
self.filetuple = None
self.plot_spaceOff = plotSpace.plotSpace()
self.plot_spaceAllan = plotSpace.plotSpace()
self.plot_spaceHist = plotSpace.plotSpace()
self.ui.plotSpace.addWidget(self.plot_spaceOff)
self.ui.plotSpace_3.addWidget(self.plot_spaceAllan)
self.ui.plotSpace_2.addWidget(self.plot_spaceHist)
self.type = 0
self.sizeOff = 0
self.numberOFTicks = 0
self.exceeds = 0
self.modified = 0
def __init__(self):
# Initializing window and UI
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setWindowTitle("Time Calculation App")
# Initializing Results Section
headers = [
'Machine', 'Planet', 'Labor (Hrs)', 'Machine Time (Hrs)',
'Setup (Hrs)', 'Test Run (Hrs)', 'Coating (Hrs)', 'Quantity',
'Yield', 'Scrap', ''
]
self.results = TableView(headers, self, 0, len(headers))
self.results.setParent(self.ui.resultsContainer)
# self.results.setFixedWidth(1265)
self.results.setFixedWidth(self.ui.resultsContainer.width())
self.results.setFixedHeight(self.ui.resultsContainer.height())
# Initialize variables needed
self.machines = [
Machine(), Machine(), Machine()
] # TODO: restructure to have planets w workorders in machines
self.techID = None
self.theme = 1
# Initialize pie chart widgets and set theme
self.initPieCharts()
self.toggleTheme()
# Connect Signals and Slots
self.ui.addWorkOrderButton.clicked.connect(
lambda: self.showWOInitDialog())
self.ui.planetConfigButton.clicked.connect(
lambda: self.showPlanetConfigDialog())
self.ui.randomButton.clicked.connect(
lambda: self.loadRandomWorkOrders())
self.ui.clearButton.clicked.connect(lambda: self.reInit())
self.ui.themeButton.clicked.connect(lambda: self.toggleTheme())
self.themeChanged.connect(lambda: self.results.setBG())
self.ui.actionSave.triggered.connect(self.browseForFile_save)
self.ui.actionLoad.triggered.connect(self.browseForFile_load)
self.ui.techIDbutton.toggled.connect(self.setTechID)
self.connectMachineSignals()
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Dialog Open
self.dialog_open = DialogOpen()
self.dialog_open.ui.buttonBox.button(
QDialogButtonBox.Ok).clicked.connect(self.load)
# Connect MainWindow view/controller to model
self.model = Model()
# Connect push buttons to slot functions
self.ui.pbShowDialogOpen.clicked.connect(self.show_dialog_open)
self.ui.pbExportFolder.clicked.connect(self.on_pbExportFolder_click)
self.ui.pbExportTurns.clicked.connect(self.export_turns)
self.ui.pbExportRoutes.clicked.connect(self.export_routes)
self.ui.pbExportLinksAndTurnsByOD.clicked.connect(
self.export_links_and_turns_by_od)
self.ui.pbEstimateOD.clicked.connect(self.estimate_od)
# Set numeric validators on objective function weight line inputs.
double_validator = QDoubleValidator(bottom=0)
double_validator.setNotation(QDoubleValidator.StandardNotation)
self.ui.leWeightGEH.setValidator(double_validator)
self.ui.leWeightODSSE.setValidator(double_validator)
self.ui.leWeightRouteRatio.setValidator(double_validator)
# set default weights
self.ui.leWeightGEH.setText("1")
self.ui.leWeightODSSE.setText("0")
self.ui.leWeightRouteRatio.setText("1")
# Setup graphics view
self.schematic_scene = schematic_scene.SchematicScene()
self.ui.gvSchematic.setScene(self.schematic_scene)
self.ui.gvSchematic.setRenderHints(QPainter.Antialiasing)
# Set table behaviors
self.ui.tblOD.setSelectionBehavior(QAbstractItemView.SelectRows)
self.ui.tblOD.setSelectionMode(QAbstractItemView.SingleSelection)
class MainWindow(QMainWindow):
def __init__(self, app, translator, parent=None):
super(MainWindow, self).__init__(parent)
self._app = app
self._translator = translator
app.installTranslator(translator)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self._setup_ui()
def _setup_ui(self):
''' '''
self._tab = AnalysisTab(self.ui.tab)
def openFile(self):
dir = os.path.dirname(__file__)
file_name, _ = QFileDialog.getOpenFileName(self, 'Open file', dir)
def __init__(self, app, translators, parent=None):
super(Mainwindow, self).__init__(parent)
self._language = menubar_actions.LANGUAGE_IDS["English"]
self._current_selected_model = None
self._current_available_datasets = None
self._current_selected_dataset = None
self.api = FMIApi()
self._settings = Settings()
self._csvexport = CsvExport(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self._set_up_ui()
self._app = app
self._translators = translators
self.update_checker = CheckUpdatesOnStartup(self._settings)
app_icon = QIcon()
app_icon.addFile('icon.ico')
app.setWindowIcon(app_icon)
class MainWindow(QMainWindow):
def __init__ (self, app, translator, parent=None):
super(MainWindow, self).__init__(parent)
self._app = app
self._translator = translator
app.installTranslator(translator)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self._setup_ui()
def _setup_ui(self):
""" """
self._uart = SerialTab(self.ui.tab)
self._modbus = ModbusTab(self.ui.tab_2)
def openFile(self):
dir = os.path.dirname(__file__)
file_name = QFileDialog.getOpenFileName(self, 'Open file', dir)
print(file_name)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.cc = ConfigurationController(self)
self.gc = GameController(self.cc, self.updateTable)
self.createConnections()
header = self.ui.tableWidget.horizontalHeader()
header.setSectionResizeMode(QHeaderView.Stretch)
header = self.ui.tableWidget.verticalHeader()
header.setSectionResizeMode(QHeaderView.Stretch)
self.imgImp = ImageImports()
self.ui.logoLabel.setPixmap(
QtGui.QPixmap(self.imgImp.logo).scaledToHeight(200))
self.updateTable()
def createConnections(self):
self.ui.fightModeAButton.pressed.connect(self.setFightModeA)
self.ui.fightModeBButton.pressed.connect(self.setFightModeB)
self.ui.fightModeCButton.pressed.connect(self.setFightModeC)
self.ui.fightModeDButton.pressed.connect(self.setFightModeD)
self.ui.fightModeEButton.pressed.connect(self.setFightModeE)
self.ui.fightModeFButton.pressed.connect(self.setFightModeF)
self.ui.toggleControlledDamageButton.pressed.connect(
self.toggleControlledDamage)
self.ui.toggleSkillsButton.pressed.connect(self.toggleSkills)
self.ui.changePartySkillButton.pressed.connect(self.changeSkills)
self.ui.toggleUltButton.pressed.connect(self.toggleUlt)
self.ui.changeHeroSkillButton.pressed.connect(self.changeUlt)
self.ui.toggleSummonsButton.pressed.connect(self.toggleSummons)
self.ui.toggleRunButton.pressed.connect(self.toggleRun)
def toggleRun(self):
if all(not thread.isAlive() for thread in threads):
t = Run(ConCon=self.cc, GameCon=self.gc)
t.setDaemon(True)
threads.append(t)
t.start()
self.cc.toggleRun()
self.updateTable()
def setFightModeA(self):
self.cc.setFightModeA()
self.updateTable()
def setFightModeB(self):
self.cc.setFightModeB()
self.updateTable()
def setFightModeC(self):
self.cc.setFightModeC()
self.updateTable()
def setFightModeD(self):
self.cc.setFightModeD()
self.updateTable()
def setFightModeE(self):
self.cc.setFightModeE()
self.updateTable()
def setFightModeF(self):
self.cc.setFightModeF()
self.updateTable()
def toggleControlledDamage(self):
self.cc.toggleControlledDamage()
self.updateTable()
def toggleSkills(self):
self.cc.toggleSkills()
self.updateTable()
def toggleUlt(self):
self.cc.toggleUlt()
self.updateTable()
def toggleSummons(self):
self.cc.toggleSummons()
self.updateTable()
def changeSkills(self):
self.cc.changeSkills()
self.updateTable()
def changeUlt(self):
self.cc.changeUlt()
self.updateTable()
def updateTable(self):
self.ui.tableWidget.setItem(0, 0, QTableWidgetItem("Enable Skills"))
self.ui.tableWidget.setItem(
0, 1, QTableWidgetItem(str(self.cc.configs.enableSkills)))
self.ui.tableWidget.setItem(0, 2,
QTableWidgetItem("Party Skill Selected"))
self.ui.tableWidget.setItem(
0, 3, QTableWidgetItem(str(self.cc.configs.ptSkillSelected)))
self.ui.tableWidget.setItem(0, 4, QTableWidgetItem("Enable Ult"))
self.ui.tableWidget.setItem(
0, 5, QTableWidgetItem(str(self.cc.configs.enableUlt)))
self.ui.tableWidget.setItem(0, 6,
QTableWidgetItem("Hero Skill Selected"))
self.ui.tableWidget.setItem(
0, 7, QTableWidgetItem(str(self.cc.configs.heroSkillSelected)))
self.ui.tableWidget.setItem(1, 0,
QTableWidgetItem("Controlled Damage"))
self.ui.tableWidget.setItem(
1, 1, QTableWidgetItem(str(self.cc.configs.controlledDamage)))
self.ui.tableWidget.setItem(1, 2, QTableWidgetItem("Summon Bosses"))
self.ui.tableWidget.setItem(
1, 3, QTableWidgetItem(str(self.cc.configs.summonBosses)))
self.ui.tableWidget.setItem(1, 4, QTableWidgetItem("Run Status"))
self.ui.tableWidget.setItem(1, 5,
QTableWidgetItem(str(self.cc.configs.run)))
self.ui.tableWidget.setItem(1, 6, QTableWidgetItem("Boss Kills"))
self.ui.tableWidget.setItem(
1, 7, QTableWidgetItem(str(self.gc.stats.killCount)))
self.ui.tableWidget.setItem(2, 0, QTableWidgetItem("Cell (2,0)"))
self.ui.tableWidget.setItem(2, 1, QTableWidgetItem("Cell (2,1)"))
self.ui.tableWidget.setItem(2, 2, QTableWidgetItem("Cell (2,2)"))
self.ui.tableWidget.setItem(2, 3, QTableWidgetItem("Cell (2,3)"))
self.ui.tableWidget.setItem(2, 4, QTableWidgetItem("Cell (2,4)"))
self.ui.tableWidget.setItem(2, 5, QTableWidgetItem("Cell (2,5)"))
self.ui.tableWidget.setItem(2, 6, QTableWidgetItem("Cell (2,6)"))
self.ui.tableWidget.setItem(2, 7, QTableWidgetItem("Cell (2,7)"))
self.ui.tableWidget.setItem(3, 0, QTableWidgetItem("Cell (3,0)"))
self.ui.tableWidget.setItem(3, 1, QTableWidgetItem("Cell (3,1)"))
self.ui.tableWidget.setItem(3, 2, QTableWidgetItem("Cell (3,2)"))
self.ui.tableWidget.setItem(3, 3, QTableWidgetItem("Cell (3,3)"))
self.ui.tableWidget.setItem(3, 4, QTableWidgetItem("Cell (3,4)"))
self.ui.tableWidget.setItem(3, 5, QTableWidgetItem("Cell (3,5)"))
self.ui.tableWidget.setItem(3, 6, QTableWidgetItem("Cell (3,6)"))
self.ui.tableWidget.setItem(3, 7, QTableWidgetItem("Cell (3,7)"))
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
class Mainwindow(QMainWindow):
# signals
setLanguageSignal = pyqtSignal(name="setLanguage")
entrySelectedSignal = pyqtSignal(dict, name="entrySelected")
def __init__(self, app, translators, parent=None):
super(Mainwindow, self).__init__(parent)
self._language = menubar_actions.LANGUAGE_IDS["English"]
self._current_selected_model = None
self._current_available_datasets = None
self._current_selected_dataset = None
self.api = FMIApi()
self._settings = Settings()
self._csvexport = CsvExport(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self._set_up_ui()
self._app = app
self._translators = translators
self.update_checker = CheckUpdatesOnStartup(self._settings)
app_icon = QIcon()
app_icon.addFile('icon.ico')
app.setWindowIcon(app_icon)
def show(self):
""" Override so that we can show possible settings dialogs right after startup """
super(Mainwindow, self).show()
self._settings.load_qsettings(self)
def set_language(self, language):
""" Set the language of the UI """
self._language = language
self._app.installTranslator(self._translators[language])
if self._current_available_datasets is not None:
self._set_available_datasets_from_catalogue(
self._current_available_datasets)
def changeEvent(self, event):
if event.type() == QEvent.LanguageChange:
self.ui.retranslateUi(self)
super(Mainwindow, self).changeEvent(event)
def _set_up_station_comboboxes(self):
""" Set station names for combobox. Configure completion."""
self.ui.stationComboBox.clear()
stations = self.api.get_stations()
completer_strings = []
for s in stations:
self.ui.stationComboBox.addItem(s["Name"])
completer_strings.append(s["Name"])
self.comboboxCompleter = QCompleter(completer_strings, self)
self.comboboxCompleter.setCompletionMode(0)
self.ui.stationComboBox.setCompleter(self.comboboxCompleter)
# Select Lammi as a first station but do not run the selection logic on first run
self.ui.stationComboBox.setCurrentIndex(
self.api.get_index_of_station("Hämeenlinna Lammi Pappila"))
self._current_selected_model = self.api.get_stations()[
self.api.get_index_of_station("Hämeenlinna Lammi Pappila")]
self.ui.stationComboBox.currentIndexChanged.connect(
self._select_place_from_combobox)
def _background_fmicatalogue_error(self, err):
"""
Handle errors which happened in fmi catalogue retrieval background thread. This is a
error callback function provided for BackgroundTask class on construction.
:param err:
:return:
"""
if err.error_code == 'NODATASETS':
self.show_error_alerts(Messages.no_datasets_found())
elif err.error_code == 'METADATA_RETRIEVAL':
self.show_error_alerts(Messages.fmicatalogue_error())
else:
self.show_error_alerts(Messages.unknown_error() + str(err))
self._current_available_datasets = None
self._current_selected_dataset = None
self.ui.dataSelectionCombobox.clear()
self._set_ui_controls_status()
def _set_ui_controls_status(self):
active = self._current_selected_dataset is not None
self.ui.downloadButton.setEnabled(active)
self.ui.endDatetimeEdit.setEnabled(active)
self.ui.startDatetimeEdit.setEnabled(active)
def _set_up_ui(self):
# language change signal
self.setLanguageSignal.connect(
lambda: menubar_actions.select_language(self, self._settings))
self._set_up_station_comboboxes()
self.catalogue_task = BackgroundTask()
self.catalogue_task.start(self.api.get_catalogue_of_station,
self._current_selected_model['FMISID'],
self._set_available_datasets_from_catalogue,
self._background_fmicatalogue_error)
# When dataset is selected
self.ui.dataSelectionCombobox.currentIndexChanged.connect(
self._select_dataset_from_combobox)
# wire download buttons to actions
self.ui.downloadButton.clicked.connect(self._download)
# wire date fields to their actions
self.ui.endDatetimeEdit.dateChanged.connect(self._date_edited)
self.ui.startDatetimeEdit.dateChanged.connect(self._date_edited)
# statusbar
self.statusBar().setStyleSheet("color: red;")
# menubar actions
self.ui.actionSet_api_key.triggered.connect(
lambda: menubar_actions.set_apikey(self, self._settings))
self.ui.actionExit.triggered.connect(menubar_actions.quit)
self.ui.actionAbout.triggered.connect(menubar_actions.about)
self.ui.actionSet_language.triggered.connect(
lambda: menubar_actions.select_language(self, self._settings))
self.ui.actionView_instructions.triggered.connect(
menubar_actions.open_manual)
self.ui.actionCheck_updates.triggered.connect(
lambda: menubar_actions.check_updates(self._settings))
@pyqtSlot(int, name='selectPlace')
def _select_place_from_combobox(self, place_index):
self.ui.stationComboBox.setCurrentIndex(place_index)
self._current_selected_model = self.api.get_stations()[place_index]
# Fetch catalog information of the current station and set datasets on completion
self.catalogue_task.start(self.api.get_catalogue_of_station,
self._current_selected_model['FMISID'],
self._set_available_datasets_from_catalogue,
self._background_fmicatalogue_error)
def _set_available_datasets_from_catalogue(self, available_datasets):
"""
Catalogue fetch completed, update contents of dataset combobox with fetched.
:param available_datasets:
:return:
"""
self._current_available_datasets = available_datasets
self.ui.dataSelectionCombobox.clear()
for q in available_datasets:
self.ui.dataSelectionCombobox.addItem(q["name"][self._language])
self.ui.dataSelectionCombobox.setCurrentIndex(0)
self._current_selected_dataset = self._current_available_datasets[0]
self._set_ui_controls_status()
self._set_time_field_limits()
@pyqtSlot(int, name='selectDataset')
def _select_dataset_from_combobox(self, dataset_index):
"""
When new dataset is selected, update time data.
:param dataset_index:
:return:
"""
if self._current_available_datasets is not None:
self._current_selected_dataset = self._current_available_datasets[
dataset_index]
self.ui.availableFromContent.setText(
datetime.datetime.strftime(
self._current_selected_dataset["starttime"], '%d.%m.%Y'))
self._set_time_field_limits()
def _set_time_field_limits(self):
# minimum date
self.ui.startDatetimeEdit.clearMinimumDate()
min_date = QDate(self._current_selected_dataset["starttime"])
self.ui.startDatetimeEdit.setMinimumDate(min_date)
self.ui.endDatetimeEdit.clearMinimumDate()
min_date = QDate(self._current_selected_dataset["starttime"])
self.ui.endDatetimeEdit.setMinimumDate(min_date)
# maximum date
self.ui.startDatetimeEdit.clearMaximumDate()
if self._current_selected_dataset["endtime"] is not None:
max_date = QDate(self._current_selected_dataset["endtime"])
else:
max_date = QDate(datetime.datetime.now().year,
datetime.datetime.now().month,
datetime.datetime.now().day)
self.ui.startDatetimeEdit.setMaximumDate(max_date)
self.ui.endDatetimeEdit.clearMaximumDate()
if self._current_selected_dataset["endtime"] is not None:
max_date = QDate(self._current_selected_dataset["endtime"])
else:
max_date = QDate(datetime.datetime.now().year,
datetime.datetime.now().month,
datetime.datetime.now().day)
self.ui.endDatetimeEdit.setMaximumDate(max_date)
new_date = QDate(self.ui.startDatetimeEdit.date().year(),
self.ui.startDatetimeEdit.date().month(),
self.ui.startDatetimeEdit.date().day() + 1)
self.ui.endDatetimeEdit.setDate(new_date)
if self.ui.startDatetimeEdit.date(
) < self.ui.startDatetimeEdit.minimumDate():
self.ui.startDatetimeEdit.setDate(
self.ui.startDatetimeEdit.minimumDate())
def _choose_place_to_save_data(self, dataframe):
paths = QStandardPaths.standardLocations(0)
if len(paths) > 0:
path = paths[0]
else:
path = ""
filename = QFileDialog.getSaveFileName(
self, Messages.save_weatherdata_csv(), path + "/weather_data.csv",
"Comma separated values CSV (*.csv);;All files (*)")
if filename[0] != "":
self._save_to_csv(dataframe, filename[0])
def _get_date_time_from_ui(self, dateEdit, onlyDate=True):
if onlyDate:
return QDateTime(dateEdit.date()).toPyDateTime()
else:
return QDateTime(dateEdit.dateTime()).toPyDateTime()
@pyqtSlot(name='editRealtimeDate')
def _date_edited(self):
"""
Date fields were edited. Check their content for invalid date ranges.
:return:
"""
if self.ui.startDatetimeEdit.date() == self.ui.endDatetimeEdit.date():
self.ui.startDatetimeEdit.setStyleSheet(
"background-color: #FC9DB7;")
self.ui.endDatetimeEdit.setStyleSheet("background-color: #FC9DB7;")
self.statusBar().showMessage(Messages.start_end_date_warning(),
5000)
self.ui.downloadButton.setEnabled(False)
else:
self.ui.startDatetimeEdit.setStyleSheet("background-color: white;")
self.ui.endDatetimeEdit.setStyleSheet("background-color: white;")
self.ui.downloadButton.setEnabled(True)
if self.ui.endDatetimeEdit.date() < self.ui.startDatetimeEdit.date(
):
self.ui.endDatetimeEdit.setStyleSheet(
"background-color: #FC9DB7;")
self.statusBar().showMessage(Messages.end_date_warning(), 5000)
self.ui.downloadButton.setEnabled(False)
else:
self.ui.endDatetimeEdit.setStyleSheet(
"background-color: white;")
self.statusBar().showMessage("", 50)
self.ui.downloadButton.setEnabled(True)
def _download(self):
""" Download weather data"""
params = {
"request":
self._current_selected_dataset["request"],
"storedquery_id":
self._current_selected_dataset["storedquery_id"],
"fmisid":
self._current_selected_model["FMISID"],
"starttime":
self._get_date_time_from_ui(self.ui.startDatetimeEdit,
onlyDate=False),
"endtime":
self._get_date_time_from_ui(self.ui.endDatetimeEdit,
onlyDate=False),
"max_hours_range":
self._current_selected_dataset["max_hours_range"]
}
download = DownloadProgress(self)
download.finishedSignal.connect(self._csvexport.save_data_to_csv)
download.begin_download(params, self.api.get_data)
def show_error_alerts(self, message):
msgbox = QMessageBox()
msgbox.information(self, "ERROR", message)
msgbox.show()
class MainWindow(QMainWindow):
"""Main window presented to the user when the program first starts."""
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Dialog Open
self.dialog_open = DialogOpen()
self.dialog_open.ui.buttonBox.button(
QDialogButtonBox.Ok).clicked.connect(self.load)
# Connect MainWindow view/controller to model
self.model = Model()
# Connect push buttons to slot functions
self.ui.pbShowDialogOpen.clicked.connect(self.show_dialog_open)
self.ui.pbExportFolder.clicked.connect(self.on_pbExportFolder_click)
self.ui.pbExportTurns.clicked.connect(self.export_turns)
self.ui.pbExportRoutes.clicked.connect(self.export_routes)
self.ui.pbExportLinksAndTurnsByOD.clicked.connect(
self.export_links_and_turns_by_od)
self.ui.pbEstimateOD.clicked.connect(self.estimate_od)
# Set numeric validators on objective function weight line inputs.
double_validator = QDoubleValidator(bottom=0)
double_validator.setNotation(QDoubleValidator.StandardNotation)
self.ui.leWeightGEH.setValidator(double_validator)
self.ui.leWeightODSSE.setValidator(double_validator)
self.ui.leWeightRouteRatio.setValidator(double_validator)
# set default weights
self.ui.leWeightGEH.setText("1")
self.ui.leWeightODSSE.setText("0")
self.ui.leWeightRouteRatio.setText("1")
# Setup graphics view
self.schematic_scene = schematic_scene.SchematicScene()
self.ui.gvSchematic.setScene(self.schematic_scene)
self.ui.gvSchematic.setRenderHints(QPainter.Antialiasing)
# Set table behaviors
self.ui.tblOD.setSelectionBehavior(QAbstractItemView.SelectRows)
self.ui.tblOD.setSelectionMode(QAbstractItemView.SingleSelection)
def show_dialog_open(self) -> None:
self.dialog_open.store_data()
self.dialog_open.show()
def load(self) -> None:
"""Load nodes, links, etc from user inputs."""
file_paths = self.dialog_open.get_data()
load_successful = self.model.load(node_file=file_paths.nodes,
links_file=file_paths.links,
od_seed_file=file_paths.seed_od,
turns_file=file_paths.turns,
od_routes_file=file_paths.routes)
if load_successful:
self.schematic_scene.load_network(self.model.get_node_xy(),
self.model.get_link_end_ids())
# Set scene rectangle to something larger than the network.
# This helps with panning & zooming near the edges of the network.
init_rect = self.schematic_scene.sceneRect()
self.schematic_scene.setSceneRect(init_rect.x() - 100000,
init_rect.y() - 100000,
init_rect.width() + 200000,
init_rect.height() + 200000)
self.ui.gvSchematic.fitInView(init_rect, Qt.KeepAspectRatio)
# Flip y coordinates to make y coordinates increasing from bottom to top.
self.ui.gvSchematic.scale(1, -1)
routes = self.model.get_route_list()
self.od_table_model = od_tablemodel.ODTableModel(routes)
self.ui.tblOD.setModel(self.od_table_model)
self.ui.tblOD.selectionModel().selectionChanged.connect(
self.on_od_table_selection)
self.schematic_scene.load_routes(routes)
def on_pbExportFolder_click(self) -> None:
"""Open a standard file dialog for selecting the export folder."""
export_folder = QFileDialog.getExistingDirectory(
self,
"Select Export Folder",
"",
options=QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks)
self.ui.leExportFolder.setText(export_folder)
def export_turns(self) -> None:
"""Export turns to csv."""
self.model.export_turns(self.ui.leExportFolder.text())
def export_routes(self) -> None:
"""Export nodes on each route."""
self.model.export_route_list(self.ui.leExportFolder.text())
def export_links_and_turns_by_od(self) -> None:
"""Export links and turns along each OD pair."""
self.model.export_node_sequence(self.ui.leExportFolder.text())
def estimate_od(self) -> None:
"""Run OD matrix estimation."""
self.model.estimate_od(
weight_total_geh=float(self.ui.leWeightGEH.text()),
weight_odsse=float(self.ui.leWeightODSSE.text()),
weight_route_ratio=float(self.ui.leWeightRouteRatio.text()))
self.model.export_od(self.ui.leExportFolder.text())
self.model.export_od_by_route(self.ui.leExportFolder.text())
def on_od_table_selection(self, selected, deselected) -> None:
"""Function called when an item in the OD Table is selected.
Parameters
----------
selected : QItemSelection
Currently selected item from the selectionModel.
deselected : QItemSelection
Items from the selectionModel that were previously selected, but
are no longer selected.
"""
# boolean flag to indicate if the table selection affects schematic_scene
should_update_scene = False
if len(deselected.indexes()) > 0:
route = self.od_table_model.get_route_at_index(
deselected.indexes()[0])
self.schematic_scene.color_route(route, is_selected=False)
should_update_scene = True
if len(selected.indexes()) > 0:
# Get route for first selected OD pair
route = self.od_table_model.get_route_at_index(
selected.indexes()[0])
self.schematic_scene.color_route(route, is_selected=True)
should_update_scene = True
if should_update_scene:
self.schematic_scene.update()
class MainWindow(QMainWindow):
themeChanged = Signal(int)
def __init__(self):
# Initializing window and UI
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setWindowTitle("Time Calculation App")
# Initializing Results Section
headers = [
'Machine', 'Planet', 'Labor (Hrs)', 'Machine Time (Hrs)',
'Setup (Hrs)', 'Test Run (Hrs)', 'Coating (Hrs)', 'Quantity',
'Yield', 'Scrap', ''
]
self.results = TableView(headers, self, 0, len(headers))
self.results.setParent(self.ui.resultsContainer)
# self.results.setFixedWidth(1265)
self.results.setFixedWidth(self.ui.resultsContainer.width())
self.results.setFixedHeight(self.ui.resultsContainer.height())
# Initialize variables needed
self.machines = [
Machine(), Machine(), Machine()
] # TODO: restructure to have planets w workorders in machines
self.techID = None
self.theme = 1
# Initialize pie chart widgets and set theme
self.initPieCharts()
self.toggleTheme()
# Connect Signals and Slots
self.ui.addWorkOrderButton.clicked.connect(
lambda: self.showWOInitDialog())
self.ui.planetConfigButton.clicked.connect(
lambda: self.showPlanetConfigDialog())
self.ui.randomButton.clicked.connect(
lambda: self.loadRandomWorkOrders())
self.ui.clearButton.clicked.connect(lambda: self.reInit())
self.ui.themeButton.clicked.connect(lambda: self.toggleTheme())
self.themeChanged.connect(lambda: self.results.setBG())
self.ui.actionSave.triggered.connect(self.browseForFile_save)
self.ui.actionLoad.triggered.connect(self.browseForFile_load)
self.ui.techIDbutton.toggled.connect(self.setTechID)
self.connectMachineSignals()
@Slot(bool)
def setTechID(self, checked):
"""
If checked, sets the techID if valid and disables text field.
Otherwise, re-enable the text field.
"""
txtField = self.ui.techID
if checked:
txt = txtField.text()
try:
self.techID = int(txt)
txtField.setReadOnly(True)
palette = QPalette()
palette.setColor(QPalette.Button, Qt.darkGreen)
palette.setColor(QPalette.ButtonText, Qt.white)
palette.setColor(QPalette.Base, QColor(100, 143, 100))
txtField.setPalette(palette)
self.ui.techIDbutton.setPalette(palette)
except:
title = "Error"
message = "Technician ID must be an integer number."
buttons = QMessageBox.Ok
message = QMessageBox(QMessageBox.Warning,
title,
message,
buttons=buttons,
flags=Qt.Dialog)
message.exec_()
self.ui.techIDbutton.setChecked(False)
self.techID = None
return
else:
self.techID = None
txtField.setReadOnly(False)
palette = QPalette()
if self.theme is 0:
palette.setColor(QPalette.Button, QColor(180, 180, 180))
palette.setColor(QPalette.ButtonText, Qt.black)
palette.setColor(QPalette.Base, QColor(140, 140, 140))
else:
palette.setColor(QPalette.Button, QColor(53, 53, 53))
palette.setColor(QPalette.Base, QColor(25, 25, 25))
txtField.setPalette(palette)
self.ui.techIDbutton.setPalette(palette)
def initPieCharts(self):
"""
Initializes pie chart widgets in 3 tabs.
Not static: needs the self variable, but it is hidden as a string.
Uses QtCharts, Planet, and QPainter imports.
"""
for i in range(1, 2): # Tab number: i
for j in range(1, 6): # Planet number: j
# Generate the necessary widgets' names
pieNum = "pie" + str(j)
infoSect = "self.ui.infoP" + str(j)
planetBox = "self.ui.planet" + str(j) + "Box"
widName = pieNum + "Container"
selfSeries = "self.ui." + pieNum + "series"
if i in [2, 3]:
selfSeries += "_" + str(i)
widName += "_" + str(i)
infoSect += "_" + str(i)
planetBox += "_" + str(i)
# Initialize commonly used custom strs
selfChart = "self.ui." + pieNum + "chart"
selfChartView = selfChart + "View"
# Store custom lines to execute (a list is easier to maintain and edit)
codeList = [
selfChart + " = QtCharts.QChart()",
selfChart + ".setTheme(QtCharts.QChart.ChartThemeLight)",
selfSeries + " = Planet(" + selfChart + ", self, " +
infoSect + ", " + planetBox + ")", selfSeries +
".planetEnabled.connect(self.checkPlanetStatuses)",
'self.themeChanged.connect(lambda theme, self=self: ' +
selfSeries + '.changeTheme(theme))', selfSeries +
".notEnoughSpaceForWO.connect(self.noSpaceLeftFor)",
selfChart + ".addSeries(" + selfSeries + ")",
selfChart + ".setBackgroundVisible(False)",
selfChart + ".legend().hide()", selfChartView +
" = QtCharts.QChartView(" + selfChart + ")",
selfChartView + ".setRenderHint(QPainter.Antialiasing)",
selfChartView + ".setParent(self.ui." + widName + ")",
selfChartView + ".resize(340, 340)",
selfChartView + ".move(-52, -52)"
]
# Convert list to string, placing newlines between each command
code = '\n'.join(codeList)
# Execute custom code
exec(code)
@Slot(WorkOrder)
def noSpaceLeftFor(self, workOrder: WorkOrder):
"""
Gives user the option to change workorder's planet, or discard the order.
"""
title = "Error: No Space Left On Planet"
message = "There isn't enough space left on the selected planet to add this order.\n" \
"An option could be placed here to change the work order's planet, but this hasn't been implemented "\
"yet, so the only option at the moment is to discard it. If this is necessary functionality and " \
"needs to be implemented, please let me know."
buttons = QMessageBox.Discard
message = QMessageBox(QMessageBox.Warning,
title,
message,
buttons=buttons,
flags=Qt.Dialog)
message.exec_()
self.deleteWorkOrder(workOrder)
def deleteWorkOrder(self, workOrder):
"""
Pretty self-explanatory name lol
"""
self.results.removeRow(workOrder.rowNum)
self.results.updateRowsFrom(workOrder.rowNum)
exec("self.ui.pie" + str(workOrder.planetNum) +
"series.deleteSlice(workOrder.slice)")
@Slot(QtCharts.QPieSlice)
def ensureSingleWorkOrder_p(self, mySlice):
"""
For signals coming from planets, when a slice was just selected.
Ensures there is only one Work Order selected per machine: the one given.
Then selects the Work Order's row in the results section.
"""
wo = mySlice.order
if not mySlice.selected:
self.deselectAllSlicesInTab(wo.machineNum,
mySlice=mySlice,
planetNum=wo.planetNum)
rowPos = wo.rowNum
self.results.selectRow(rowPos)
else:
pie = "self.ui.pie" + str(wo.planetNum) + "series"
exec(pie + ".clickSlice(mySlice)")
@Slot(int, int)
def ensureSingleWorkOrder_r(self, row, col):
"""
For signals coming from the results section, when a cell of a row is selected.
Ensures there is only one Work Order selected per machine: the one given.
Then selects the corresponding slice in the pie charts
"""
wo = self.results.rowNumToWOMapping[row]
self.deselectAllSlicesInTab(wo.machineNum,
mySlice=wo.slice,
planetNum=wo.planetNum)
def deselectAllSlicesInTab(self, tab, mySlice=None, planetNum=None):
"""
Optional param is the one slice you do want selected.
Note: Not static. Uses self, but it is hidden as string.
"""
for j in range(1, 6): # Planet number: j
pie = "self.ui.pie" + str(j) + "series"
if tab in [2, 3]:
pie += "_" + str(tab)
exec(pie + ".deselectAll()")
if mySlice and j == planetNum:
exec(pie + ".clickSlice(mySlice)")
@Slot()
def browseForFile_save(self) -> None:
"""
Opens a file dialog when the user clicks on the "Save As..." option to choose a file to save to.
"""
if self.techID:
fileDialog = QFileDialog()
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setDirectory(os.getcwd())
fileDialog.setDefaultSuffix(".proj")
fileDialog.setNameFilter("Project (*.proj)")
fileDialog.fileSelected.connect(lambda url: self.saveFile(url))
fileDialog.exec_()
else:
title = "Error"
message = "Must set Technician ID to save project."
buttons = QMessageBox.Ok
message = QMessageBox(QMessageBox.Warning,
title,
message,
buttons=buttons,
flags=Qt.Dialog)
message.exec_()
@Slot()
def browseForFile_load(self) -> None:
"""
Opens a file dialog when the user clicks on the "Save As..." option to choose a file to save to.
"""
fileDialog = QFileDialog()
fileDialog.setFileMode(QFileDialog.ExistingFile)
fileDialog.setDirectory(os.getcwd())
fileDialog.setNameFilter("Project (*.proj)")
fileDialog.fileSelected.connect(lambda url: self.loadFile(url))
fileDialog.exec_()
def saveFile(self, path):
"""
Saves data to file, at location "path".
"""
# Create dictionary first. All we really care about is the work orders, so we'll just save the list of them.
d = {'techID': self.techID}
for tab, machine in enumerate(self.machines):
if tab == 0: # TODO: change
d[tab] = {}
d[tab]['workOrders'] = {}
for wo in machine.workOrders:
d[tab]['workOrders'][wo.name] = [
wo.pieces, wo.side, wo.planetNum, wo.yld
]
d[tab]['startTime'] = machine.startTime
d[tab]['endTime'] = machine.endTime
d[tab]['loadTime'] = machine.loadTime
d[tab]['unloadTime'] = machine.unloadTime
d[tab]['cdn'] = machine.cdn
d[tab]['testRun'] = machine.testRun
d[tab]['coatingRun'] = machine.coatingRun
d[tab]['loadingRun'] = machine.loadingRun
d[tab]['setupRun'] = machine.setupRun
# Storing planets' sum values.
d[tab]['planets'] = {}
for planet in range(1, 6):
pie = 'self.ui.pie' + str(planet) + 'series'
if tab in (1, 2):
pie += '_' + str(tab + 1)
exec('tmp = ' + pie + '.enabled', locals())
if locals()['tmp']:
exec('sum = ' + pie + '.sum()', locals())
d[tab]['planets'][planet] = locals()['sum']
else:
d[tab]['planets'][planet] = None
# Now save to file.
with open(path, 'wb') as f:
pickle.dump(d, f)
def loadFile(self, path):
"""
Attempts to load the file at path
"""
error = False
if path[-5:] == '.proj':
try:
# Load dictionary from file
with open(path, 'rb') as f:
p = pickle.Unpickler(f)
d = p.load()
if not p:
# file is empty
error = True # Checks if file is empty
else:
self.techID = d['techID']
self.ui.techID.setText(str(self.techID))
self.ui.techIDbutton.setChecked(True)
for tab in range(0, 1): # TODO: Change
machine = self.machines[tab]
# Load all values
startTime = d[tab]['startTime']
endTime = d[tab]['endTime']
loadTime = d[tab]['loadTime']
unloadTime = d[tab]['unloadTime']
cdn = d[tab]['cdn']
testRun = d[tab]['testRun']
coatingRun = d[tab]['coatingRun']
loadingRun = d[tab]['loadingRun']
setupRun = d[tab]['setupRun']
# Check if they exist
if startTime:
machine.startTime = startTime
time = QTime().fromString(startTime)
tmp = 'self.ui.startTime'
but = 'self.ui.stButton'
if tab in (1, 2):
tmp += '_' + str(tab + 1)
but += '_' + str(tab + 1)
exec(tmp + '.setTime(time)')
exec(but + '.setChecked(True)')
if endTime:
machine.endTime = endTime
time = QTime().fromString(endTime)
tmp = 'self.ui.endTime'
but = 'self.ui.etButton'
if tab in (1, 2):
tmp += '_' + str(tab + 1)
but += '_' + str(tab + 1)
exec(tmp + '.setTime(time)')
exec(but + '.setChecked(True)')
if loadTime:
machine.loadTime = loadTime
time = QTime().fromString(loadTime)
tmp = 'self.ui.loadTime'
but = 'self.ui.ltButton'
if tab in (1, 2):
tmp += '_' + str(tab + 1)
but += '_' + str(tab + 1)
exec(tmp + '.setTime(time)')
exec(but + '.setChecked(True)')
if unloadTime:
machine.unloadTime = unloadTime
time = QTime().fromString(unloadTime)
tmp = 'self.ui.unloadTime'
but = 'self.ui.utButton'
if tab in (1, 2):
tmp += '_' + str(tab + 1)
but += '_' + str(tab + 1)
exec(tmp + '.setTime(time)')
exec(but + '.setChecked(True)')
if cdn: # If there's the cdn, the other 4 are there too
machine.cdn = cdn
machine.testRun = testRun
machine.coatingRun = coatingRun
machine.loadingRun = loadingRun
machine.setupRun = setupRun
cdnBox = 'self.ui.cdn'
testBox = 'self.ui.testRun'
coatBox = 'self.ui.coatRun'
loadBox = 'self.ui.loadingRun'
setupBox = 'self.ui.setupTestRun'
vButton = 'self.ui.validateButton'
if tab in (1, 2):
cdnBox += '_' + str(tab + 1)
testBox += '_' + str(tab + 1)
coatBox += '_' + str(tab + 1)
loadBox += '_' + str(tab + 1)
setupBox += '_' + str(tab + 1)
vButton += '_' + str(tab + 1)
codeList = [
cdnBox + '.setText(str(cdn))',
testBox + '.setText(str(testRun))',
coatBox + '.setText(str(coatingRun))',
loadBox + '.setText(str(loadingRun))',
setupBox + '.setText(str(setupRun))',
vButton + '.setChecked(True)'
]
code = '\n'.join(codeList)
exec(code)
# Initialize planets
for planetNum in d[tab]['planets']:
sum = d[tab]['planets'][planetNum]
if sum:
pie = 'self.ui.pie' + str(planetNum) + 'series'
if tab in (1, 2):
pie += '_' + str(tab + 1)
exec(pie + '.setEnabled(sum)')
sortedWOList = []
for woName in d[tab]['workOrders']:
params = d[tab]['workOrders'][woName]
wo = WorkOrder()
wo.name = woName
wo.machineNum = tab + 1
wo.pieces = params[0]
wo.side = params[1]
wo.planetNum = params[2]
if params[3]:
wo.setYield(params[3])
sortedWOList.append(wo)
sortedWOList.sort(
key=lambda workOrder: int(workOrder.name[4:]))
unsuccessful = []
for wo in sortedWOList:
success = self.addToPlanets(wo)
if success:
self.results.addRowFor(wo)
self.machines[wo.machineNum -
1].workOrders.append(wo)
else:
unsuccessful.append(wo)
if unsuccessful:
for wo in unsuccessful:
print(wo.name)
except Exception as e:
raise e
else:
# not a proj file
error = True
if error:
title = "Error Loading Project"
message = "Could not load the selected file successfully."
buttons = QMessageBox.Ok
message = QMessageBox(QMessageBox.Warning,
title,
message,
buttons=buttons,
flags=Qt.Dialog)
message.exec_()
@Slot(bool)
def checkPlanetStatuses(self, enabled):
"""
If a planet is switched to enabled, this unlocks the save as button.
Otherwise if a planet is switched to disabled, this does a application-wide check to see
if any other planets are currently enabled. If not, disables the save as button.
"""
if enabled:
if not self.ui.actionSave.isEnabled():
self.ui.actionSave.setEnabled(True)
else:
if self.ui.actionSave.isEnabled():
atLeastOneEnabled = False
for machine in range(
1, 2
): # 3 tabs TODO: Change 1 to 3 when other tabs are implemented
for planet in range(1, 6): # 5 planets
pie = "self.ui.pie" + str(planet) + "series"
if machine in [2, 3]:
pie += "_" + str(machine)
if exec(pie + '.enabled'):
atLeastOneEnabled = True
break
if atLeastOneEnabled:
break
if not atLeastOneEnabled:
self.ui.actionSave.setEnabled(False)
def startTimeCheck(self, checked, machine, timeBox, button):
"""
If the button next to the time is clicked (checked), this handles what to do with the data and gui.
If it is unchecked, the data is deleted and the timeObject is enabled.
"""
if checked:
machine.startTime = timeBox.time().toString()
timeBox.setReadOnly(True)
palette = QPalette()
palette.setColor(QPalette.Button, Qt.darkGreen)
palette.setColor(QPalette.ButtonText, Qt.white)
button.setPalette(palette)
timeBox.setPalette(palette)
else:
machine.startTime = None
timeBox.setReadOnly(False)
palette = QPalette()
if self.theme is 0:
palette.setColor(QPalette.Button, QColor(180, 180, 180))
palette.setColor(QPalette.ButtonText, Qt.black)
else:
palette.setColor(QPalette.Button, QColor(53, 53, 53))
button.setPalette(palette)
timeBox.setPalette(palette)
self.updateResults(machine)
def endTimeCheck(self, checked, machine, timeBox, button):
"""
If the button next to the time is clicked (checked), this handles what to do with the data and gui.
If it is unchecked, the data is deleted and the timeObject is enabled.
"""
if checked:
machine.endTime = timeBox.time().toString()
timeBox.setReadOnly(True)
palette = QPalette()
palette.setColor(QPalette.Button, Qt.darkGreen)
palette.setColor(QPalette.ButtonText, Qt.white)
button.setPalette(palette)
timeBox.setPalette(palette)
else:
machine.endTime = None
timeBox.setReadOnly(False)
palette = QPalette()
if self.theme is 0:
palette.setColor(QPalette.Button, QColor(180, 180, 180))
palette.setColor(QPalette.ButtonText, Qt.black)
else:
palette.setColor(QPalette.Button, QColor(53, 53, 53))
button.setPalette(palette)
timeBox.setPalette(palette)
self.updateResults(machine)
def loadTimeCheck(self, checked, machine, timeBox, button):
"""
If the button next to the time is clicked (checked), this handles what to do with the data and gui.
If it is unchecked, the data is deleted and the timeObject is enabled.
"""
if checked:
machine.loadTime = timeBox.time().toString()
timeBox.setReadOnly(True)
palette = QPalette()
palette.setColor(QPalette.Button, Qt.darkGreen)
palette.setColor(QPalette.ButtonText, Qt.white)
button.setPalette(palette)
timeBox.setPalette(palette)
else:
machine.loadTime = None
timeBox.setReadOnly(False)
palette = QPalette()
if self.theme is 0:
palette.setColor(QPalette.Button, QColor(180, 180, 180))
palette.setColor(QPalette.ButtonText, Qt.black)
else:
palette.setColor(QPalette.Button, QColor(53, 53, 53))
button.setPalette(palette)
timeBox.setPalette(palette)
self.updateResults(machine)
def unloadTimeCheck(self, checked, machine, timeBox, button):
"""
If the button next to the time is clicked (checked), this handles what to do with the data and gui.
If it is unchecked, the data is deleted and the timeObject is enabled.
"""
if checked:
machine.unloadTime = timeBox.time().toString()
timeBox.setReadOnly(True)
palette = QPalette()
palette.setColor(QPalette.Button, Qt.darkGreen)
palette.setColor(QPalette.ButtonText, Qt.white)
button.setPalette(palette)
timeBox.setPalette(palette)
else:
machine.unloadTime = None
timeBox.setReadOnly(False)
palette = QPalette()
if self.theme is 0:
palette.setColor(QPalette.Button, QColor(180, 180, 180))
palette.setColor(QPalette.ButtonText, Qt.black)
else:
palette.setColor(QPalette.Button, QColor(53, 53, 53))
button.setPalette(palette)
timeBox.setPalette(palette)
self.updateResults(machine)
def validateData(self, checked, tab):
"""
If checked, loads data from all text fields around validate button, and disables them. Also changes button text.
Otherwise, enables all fields, clears data, and changes button text back.
"""
cdnBox = "self.ui.cdn"
testBox = "self.ui.testRun"
coatBox = "self.ui.coatRun"
loadBox = "self.ui.loadingRun"
setupBox = "self.ui.setupTestRun"
vButton = "self.ui.validateButton"
machine = "self.machines[" + str(tab - 1) + "]"
if tab in (2, 3):
cdnBox += "_" + str(tab)
testBox += "_" + str(tab)
coatBox += "_" + str(tab)
loadBox += "_" + str(tab)
setupBox += "_" + str(tab)
vButton += "_" + str(tab)
if checked:
codeList = [
'cdn = ' + cdnBox + '.text()',
'testRun = ' + testBox + '.text()',
'coatingRun = ' + coatBox + '.text()',
'loadingRun = ' + loadBox + '.text()',
'setupRun = ' + setupBox + '.text()',
'locals()["valid"] = self.checkValidity(cdn, testRun, coatingRun, loadingRun, setupRun)'
]
code = '\n'.join(codeList)
exec(code)
if locals()["valid"]:
codeList = [
machine + '.cdn = int(' + cdnBox + '.text())',
machine + '.testRun = float(' + testBox + '.text())',
machine + '.coatingRun = float(' + coatBox + '.text())',
machine + '.loadingRun = float(' + loadBox + '.text())',
machine + '.setupRun = float(' + setupBox + '.text())',
cdnBox + '.setReadOnly(True)', testBox +
'.setReadOnly(True)', coatBox + '.setReadOnly(True)',
loadBox + '.setReadOnly(True)',
setupBox + '.setReadOnly(True)',
vButton + '.setText("Unlock")', 'palette = QPalette()',
'palette.setColor(QPalette.Button, Qt.darkGreen)',
'palette.setColor(QPalette.ButtonText, Qt.white)',
'palette.setColor(QPalette.Base, QColor(100, 143, 100))',
vButton + '.setPalette(palette)', cdnBox +
'.setPalette(palette)', testBox + '.setPalette(palette)',
coatBox + '.setPalette(palette)', loadBox +
'.setPalette(palette)', setupBox + '.setPalette(palette)'
]
else:
codeList = [vButton + '.setChecked(False)']
else:
palette = QPalette()
if self.theme is 0:
palette.setColor(QPalette.Button, QColor(180, 180, 180))
palette.setColor(QPalette.ButtonText, Qt.black)
palette.setColor(QPalette.Base, QColor(140, 140, 140))
else:
palette.setColor(QPalette.Button, QColor(53, 53, 53))
palette.setColor(QPalette.Base, QColor(25, 25, 25))
codeList = [
machine + '.cdn = None', machine + '.testRun = None',
machine + '.coatingRun = None', machine + '.loadingRun = None',
machine + '.setupRun = None', cdnBox + '.setReadOnly(False)',
testBox + '.setReadOnly(False)', coatBox +
'.setReadOnly(False)', loadBox + '.setReadOnly(False)',
setupBox + '.setReadOnly(False)', vButton + '.setText("Lock")',
vButton + '.setPalette(palette)', cdnBox +
'.setPalette(palette)', testBox + '.setPalette(palette)',
coatBox + '.setPalette(palette)', loadBox +
'.setPalette(palette)', setupBox + '.setPalette(palette)'
]
code = '\n'.join(codeList)
exec(code)
self.updateResults(self.machines[tab - 1])
def checkValidity(self, cdn, testRun, coatingRun, loadingRun, setupRun):
"""
Checks if all inputs are valid types.
"""
try:
int(cdn)
float(testRun)
float(coatingRun)
float(loadingRun)
float(setupRun)
return True
except:
title = "Error"
message = "At least one of the text fields does not have a numerical entry."
buttons = QMessageBox.Ok
message = QMessageBox(QMessageBox.Warning,
title,
message,
buttons=buttons,
flags=Qt.Dialog)
message.exec_()
return False
def updateResults(self, machine):
"""
When a button is pressed in a machine, this function makes sure
to update its work orders with the correct values.
"""
for workOrder in machine.workOrders:
self.results.updateRowInfo(workOrder)
def connectMachineSignals(self):
"""
Connects all time and textbox signals for each machine.
Note: Not static. Uses self variable, but hidden as string.
"""
for tab in range(
1, 2): # TODO: Change 2 to 4 when other tabs are implemented.
# Instantiate button names
stButton = "self.ui.stButton"
stBox = "self.ui.startTime"
etButton = "self.ui.etButton"
etBox = "self.ui.endTime"
ltButton = "self.ui.ltButton"
ltBox = "self.ui.loadTime"
utButton = "self.ui.utButton"
utBox = "self.ui.unloadTime"
vButton = "self.ui.validateButton"
machine = "self.machines[" + str(tab - 1) + "]"
if tab in (2, 3):
stButton += "_" + str(tab)
etButton += "_" + str(tab)
ltButton += "_" + str(tab)
utButton += "_" + str(tab)
vButton += "_" + str(tab)
# List of code to run
codeList = [
stButton +
".toggled.connect(lambda checked, self=self: self.startTimeCheck(checked, "
+ machine + ", " + stBox + ", " + stButton + "))", etButton +
".toggled.connect(lambda checked, self=self: self.endTimeCheck(checked, "
+ machine + ", " + etBox + ", " + etButton + "))", ltButton +
".toggled.connect(lambda checked, self=self: self.loadTimeCheck(checked, "
+ machine + ", " + ltBox + ", " + ltButton + "))", utButton +
".toggled.connect(lambda checked, self=self: self.unloadTimeCheck(checked, "
+ machine + ", " + utBox + ", " + utButton + "))", vButton +
".toggled.connect(lambda checked, self=self: self.validateData(checked, "
+ str(tab) + "))"
]
code = '\n'.join(codeList)
exec(code)
def showWOInitDialog(self, wo=None):
"""
Shows the Work Order Dialog and does some extra action handling
"""
if not wo:
wo = WorkOrder()
woDialog = WorkOrderDialog(self, wo)
result = woDialog.exec_()
if result == QDialog.Rejected:
return
else:
success = self.addToPlanets(wo)
if not success:
self.showWOInitDialog(wo)
return
self.results.addRowFor(wo)
self.machines[wo.machineNum - 1].workOrders.append(wo)
def updateWorkOrder(self, workOrder: WorkOrder):
"""
Updates visual information about workOrder.
"""
workOrder.slice.setValue(workOrder.pieces)
workOrder.slice.parent().updateHeader()
if workOrder.slice.selected:
workOrder.slice.parent().clickSlice(workOrder.slice)
workOrder.slice.parent().clickSlice(workOrder.slice)
self.results.updateRowInfo(workOrder)
def addToPlanets(self, workOrder: WorkOrder):
"""
Adds a new work order to its planet
"""
pie = "self.ui.pie" + str(workOrder.planetNum) + "series"
if workOrder.machineNum in (2, 3):
pie += "_" + str(workOrder.machineNum)
exec('success = ' + pie + '.addSlice(workOrder)', locals())
return locals()['success']
def showPlanetConfigDialog(self):
"""
Shows the planet configuration dialog
"""
pcd = PlanetConfigDialog(self)
pcd.exec_()
def reInit(self, alreadyWarned=False):
"""
Clears all info
"""
result = None
if not alreadyWarned:
title = "Warning"
message = "This will clear all work orders, and cannot be undone. Continue?"
buttons = QMessageBox.Ok | QMessageBox.Cancel
message = QMessageBox(QMessageBox.Warning,
title,
message,
buttons=buttons,
flags=Qt.Dialog)
result = message.exec_()
if alreadyWarned or result == QMessageBox.Ok:
for num, machine in enumerate(self.machines):
for workOrder in machine.workOrders:
self.deleteWorkOrder(workOrder)
if num is 0: # TODO: Remove when other tabs are implemented
for planetNum in range(1, 6):
planet = 'self.ui.pie' + str(planetNum) + 'series'
if num in (1, 2):
planet += '_' + str(num + 1)
exec(planet + '.setDisabled()')
machine.workOrders.clear()
def toggleTheme(self):
"""
Changes between light and dark theme. 0 is light, 1 is dark
"""
qApp = QApplication.instance()
if self.theme is 0:
qApp.setStyle("Fusion")
dark_palette = QPalette()
dark_palette.setColor(QPalette.Window, QColor(53, 53, 53))
dark_palette.setColor(QPalette.WindowText, Qt.white)
dark_palette.setColor(QPalette.Base, QColor(25, 25, 25))
dark_palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ToolTipBase, Qt.white)
dark_palette.setColor(QPalette.ToolTipText, Qt.white)
dark_palette.setColor(QPalette.Text, Qt.white)
dark_palette.setColor(QPalette.Button, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ButtonText, Qt.white)
dark_palette.setColor(QPalette.BrightText, Qt.red)
dark_palette.setColor(QPalette.Link, QColor(42, 130, 218))
dark_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
dark_palette.setColor(QPalette.HighlightedText, Qt.black)
dark_palette.setColor(QPalette.Disabled, QPalette.Text,
QColor(190, 190, 190))
dark_palette.setColor(QPalette.Disabled, QPalette.ButtonText,
Qt.darkGray)
qApp.setPalette(dark_palette)
qApp.setStyleSheet(
"QToolTip { color: #ffffff; background-color: #2a82da; border: 1px solid white; }"
)
self.theme = 1
self.ui.themeButton.setText("Dark Mode")
self.themeChanged.emit(self.theme)
else:
qApp.setStyle("Fusion")
palette = QPalette()
palette.setColor(QPalette.Window, QColor(180, 180, 180))
palette.setColor(QPalette.WindowText, Qt.black)
palette.setColor(QPalette.Base, QColor(140, 140, 140))
palette.setColor(QPalette.AlternateBase, QColor(180, 180, 180))
palette.setColor(QPalette.ToolTipBase, Qt.black)
palette.setColor(QPalette.ToolTipText, Qt.black)
palette.setColor(QPalette.Text, Qt.black)
palette.setColor(QPalette.Button, QColor(180, 180, 180))
palette.setColor(QPalette.ButtonText, Qt.black)
palette.setColor(QPalette.BrightText, Qt.red)
palette.setColor(QPalette.Link, QColor(42, 130, 218))
palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
palette.setColor(QPalette.HighlightedText, Qt.white)
palette.setColor(QPalette.Disabled, QPalette.Text,
QColor(60, 60, 60))
palette.setColor(QPalette.Disabled, QPalette.ButtonText,
Qt.darkGray)
qApp.setPalette(palette)
qApp.setStyleSheet(
"QToolTip { color: #ffffff; background-color: #2a82da; border: 1px solid white; }"
)
self.theme = 0
self.ui.themeButton.setText("Light Mode")
self.themeChanged.emit(self.theme)
def loadRandomWorkOrders(self):
"""
Iteratively creates random work orders. Loads data into
planets 1-4 and the table at the bottom, ***only in Tab 1***.
Not static: needs the self variable, but it is hidden as a string.
"""
title = "Warning"
message = "Running the demo will clear all current work orders. Continue?"
buttons = QMessageBox.Ok | QMessageBox.Cancel
message = QMessageBox(QMessageBox.Warning,
title,
message,
buttons=buttons,
flags=Qt.Dialog)
result = message.exec_()
if result == QMessageBox.Ok:
self.reInit(True)
c = 1
for i in range(1, 5): # The first 4 planets
# Get current pie's name, initialize that pieSeries
curPie = "self.ui.pie" + str(i) + "series"
exec(curPie + ".setEnabled(100)")
# Randomly generate some WorkOrders for this pie, add them
# as slices to pie, and add data to results.
for j in range(1, 5):
# Random num of pcs and side choice
numPcs = randrange(1, 26)
side = randrange(1, 3)
# Set name, create WorkOrder
name = "WO #" + str(c)
c += 1
tmpWO = WorkOrder()
tmpWO.name = name
tmpWO.pieces = numPcs
tmpWO.side = side
tmpWO.planetNum = i
tmpWO.machineNum = 1
# Create slice for WorkOrder, add it to mapping, add it to results
exec(curPie + ".addSlice(tmpWO)")
self.results.addRowFor(tmpWO)
self.machines[0].workOrders.append(tmpWO)
class MainWindow(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.connectActions()
self.loopProcessor = loopLoader.loopLoader()
self.logProcessor = logProcessing.logProcess()
self.runProcessor = Runner.allanandPlots()
self.filename = None
self.filetuple = None
self.plot_spaceOff = plotSpace.plotSpace()
self.plot_spaceAllan = plotSpace.plotSpace()
self.plot_spaceHist = plotSpace.plotSpace()
self.ui.plotSpace.addWidget(self.plot_spaceOff)
self.ui.plotSpace_3.addWidget(self.plot_spaceAllan)
self.ui.plotSpace_2.addWidget(self.plot_spaceHist)
self.type = 0
self.sizeOff = 0
self.numberOFTicks = 0
self.exceeds = 0
self.modified = 0
def connectActions(self):
self.ui.actionNtpStatus.connect(PySide.QtCore.SIGNAL("triggered()"), self.aboutBox)
self.ui.actionLoopstats.connect(PySide.QtCore.SIGNAL("triggered()"), self.fileLoopstats)
self.ui.actionLoadLopstats.connect(PySide.QtCore.SIGNAL("triggered()"), self.fileLoopstats)
self.ui.actionLoadRun.connect(PySide.QtCore.SIGNAL("triggered()"), self.fileRun)
self.ui.actionRun_File.connect(PySide.QtCore.SIGNAL("triggered()"), self.fileRun)
self.ui.actionLoadLog.connect(PySide.QtCore.SIGNAL("triggered()"), self.fileLog)
self.ui.actionLog_File.connect(PySide.QtCore.SIGNAL("triggered()"), self.fileLog)
self.ui.actionPlot.connect(PySide.QtCore.SIGNAL("triggered()"), self.generatePlot)
self.ui.actionSave.connect(PySide.QtCore.SIGNAL("triggered()"), self.plotSave)
self.connect(self.ui.actionExit, QtCore.SIGNAL('triggered()'), self.close)
def aboutBox(self):
QMessageBox.about(self, "About NTPStats 2012",
"""<b>Google Summer of Code 2012.</b> v %s
<p>Copyright © 2012 Google and NTP.
All rights reserved in accordance with
GPL v2.
<p>This programs plots the Allan Deviation and Offsets for\
logs of NTP Runs.
<p> Developed by Thiago de Freitas Oliveira Araujo
<p>Python %s - PySide version %s - Qt version %s on\
%s""" % (__version__, platform.python_version(),\
PySide.__version__, PySide.QtCore.__version__,
platform.system()))
def closeEvent(self, event):
reply = QtGui.QMessageBox.question(self, 'Leave NTPStats',
"Are you sure to quit?", QtGui.QMessageBox.No |
QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
event.accept()
else:
event.ignore()
def fileLoopstats(self):
if self.ui.tabWidget.currentIndex():
self.oktoLoad()
return
else:
dir = (os.path.dirname(self.filename)
if self.filename is not None else ".")
self.filetuple = QFileDialog.getOpenFileName(self,\
"Open Loopstats File", dir,\
"Data (*.dat *.txt)\nAll Files (*.*)")
self.filename = self.filetuple[0]
fname = self.filename
if fname:
self.loopProcessor.processLoopStats(fname)
self.loadFile(fname)
self.updateStatus('New Loopstats file opened.')
[self.loopProcessor.timeS, self.loopProcessor.av, self.loopProcessor.error] = self.loopProcessor.Allan.allanDevMills(self.loopProcessor.offsets)
self.type = 1
self.sizeOff = len(self.loopProcessor.offsets)
if(self.sizeOff%84 != 0):
self.exceeds = self.sizeOff%84
self.numberOFTicks = scipy.ceil((float)(self.sizeOff)/84)
self.ui.spinBox.setRange(1,self.numberOFTicks)
def fileRun(self):
if self.ui.tabWidget.currentIndex():
self.oktoLoad()
return
else:
dir = (os.path.dirname(self.filename)
if self.filename is not None else ".")
self.filetuple = QFileDialog.getOpenFileName(self,\
"Open Generated Times File", dir,\
"Data (*.dat *.txt)\nAll Files (*.*)")
self.filename = self.filetuple[0]
fname = self.filename
dir = (os.path.dirname(self.filename)
if self.filename is not None else ".")
self.filetuple = QFileDialog.getOpenFileName(self,\
"Open Generated Offsets File", dir,\
"Data (*.dat *.txt)\nAll Files (*.*)")
self.filename = self.filetuple[0]
fname2 = self.filename
if fname:
self.runProcessor.processOffsets(fname, fname2)
self.loadFile(fname)
self.updateStatus('New Run Statistics File opened.')
[self.runProcessor.timeS, self.runProcessor.av, self.runProcessor.error] = self.runProcessor.Allan.allanDevMills(self.runProcessor.offsets)
self.type = 2
self.sizeOff = len(self.runProcessor.offsets)
if(self.sizeOff%84 != 0):
self.exceeds = self.sizeOff%84
self.numberOFTicks = scipy.ceil((float)(self.sizeOff)/84)
self.ui.spinBox.setRange(1,self.numberOFTicks)
def fileLog(self):
if self.ui.tabWidget.currentIndex():
self.oktoLoad()
return
else:
dir = (os.path.dirname(self.filename)
if self.filename is not None else ".")
self.filetuple = QFileDialog.getOpenFileName(self,\
"Open Log File", dir,\
"Data (*.log)\nAll Files (*.*)")
self.filename = self.filetuple[0]
fname = self.filename
if fname:
self.logProcessor.processLog(fname)
self.loadFile(fname)
self.updateStatus('New Log file opened.')
[self.logProcessor.timeS, self.logProcessor.av, self.logProcessor.error] = self.logProcessor.Allan.allanDevMills(self.logProcessor.offsets)
self.type = 3
self.sizeOff = len(self.logProcessor.offsets)
if(self.sizeOff%84 != 0):
self.exceeds = self.sizeOff%84
self.numberOFTicks = scipy.ceil((float)(self.sizeOff)/84)
self.ui.spinBox.setRange(1,self.numberOFTicks)
def oktoPlot(self):
reply = QMessageBox.warning(self,
"Warning",
'''\nPlotting is only possible at a Plot tab!''', QMessageBox.Ok)
return True
def oktoLoad(self):
reply = QMessageBox.warning(self,
"Warning",
'''\nLoading is only possible at the Contents Tab!''', QMessageBox.Ok)
return True
def oktoSavePlot(self):
reply = QMessageBox.warning(self,
"Warning",
'''\nPlot Save is only possible at a Plot tab!''', QMessageBox.Ok)
return True
def loadFile(self, fname=None):
fl = open(fname)
text = fl.read()
self.ui.textEdit.setPlainText(text)
def plotSave(self):
if not (self.ui.tabWidget.currentIndex()):
self.oktoSavePlot()
return
elif self.ui.tabWidget.currentIndex()==1:
nameSave = self.ui.nametoSave.text()
self.plot_spaceOff.save_plot(nameSave)
elif self.ui.tabWidget.currentIndex()==2:
nameSave = self.ui.nametoSave_3.text()
self.plot_spaceAllan.save_plot(nameSave)
elif self.ui.tabWidget.currentIndex()==3:
nameSave = self.ui.nametoSave_2.text()
self.plot_spaceHist.save_plot(nameSave)
def updateStatus(self, message):
if self.filename is not None:
fileN = os.path.basename(self.filename)
self.setWindowTitle(unicode("Statistics File - " +\
fileN + "[*]") )
self.statusBar().showMessage(message, 5000)
def generatePlot(self):
if not (self.ui.tabWidget.currentIndex()):
self.oktoPlot()
return
elif self.ui.tabWidget.currentIndex()==1: #Offsets
if(self.type == 1): # LOOPSTATS
if not self.modified:
self.loopProcessor.seconds = np.asarray(self.loopProcessor.seconds)
self.loopProcessor.day = np.asarray(self.loopProcessor.day)
self.loopProcessor.seconds += (self.loopProcessor.day - self.loopProcessor.day[0]) * 86400
self.loopProcessor.seconds /= 3600
self.modified = 1
if self.ui.radioButton.isChecked():
if self.ui.radioButton_2.isChecked():
if not self.exceeds:
range_min = (self.ui.spinBox.value()-1)*84
range_max = range_min + 84
self.plot_spaceOff.plotMinusLeastSquares(1, self.loopProcessor.offsets[range_min:range_max], self.loopProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.loopProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.loopProcessor.secondsPure[range_max])
self.ui.textEdit_2.setText(smallText)
else:
range_min = (self.ui.spinBox.value()-1)*84
range_max = (self.ui.spinBox.value()*84)
if(self.ui.spinBox.value() == self.numberOFTicks):
range_max = range_min + self.exceeds
self.plot_spaceOff.plotMinusLeastSquares(1, self.loopProcessor.offsets[range_min:range_max], self.loopProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.loopProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.loopProcessor.secondsPure[range_max-1])
self.ui.textEdit_2.setText(smallText)
else:
if not self.exceeds:
range_min = (self.ui.spinBox.value()-1)*84
range_max = range_min + 84
self.plot_spaceOff.update_plot(1, self.loopProcessor.offsets[range_min:range_max], self.loopProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.loopProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.loopProcessor.secondsPure[range_max])
self.ui.textEdit_2.setText(smallText)
else:
range_min = (self.ui.spinBox.value()-1)*84
range_max = (self.ui.spinBox.value()*84)
if(self.ui.spinBox.value() == self.numberOFTicks):
range_max = range_min + self.exceeds
self.plot_spaceOff.update_plot(1, self.loopProcessor.offsets[range_min:range_max], self.loopProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.loopProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.loopProcessor.secondsPure[range_max-1])
self.ui.textEdit_2.setText(smallText)
else:
if self.ui.radioButton_2.isChecked():
self.plot_spaceOff.plotMinusLeastSquares(1, self.loopProcessor.offsets, self.loopProcessor.seconds, av=None, error=None, timeS=None, tickCorrect=0)
smallText = "Initial Time:" + "\n" + ctime(self.loopProcessor.secondsPure[0]) + "\n" +\
"Final Time:" + "\n" + ctime(self.loopProcessor.secondsPure[-1])
self.ui.textEdit_2.setText(smallText)
else:
self.plot_spaceOff.update_plot(1, self.loopProcessor.offsets, self.loopProcessor.seconds, av=None, error=None, timeS=None, tickCorrect=0)
smallText = "Initial Time:" + "\n" + ctime(self.loopProcessor.secondsPure[0]) + "\n" +\
"Final Time:" + "\n" + ctime(self.loopProcessor.secondsPure[-1])
self.ui.textEdit_2.setText(smallText)
####
####
elif(self.type == 2): #RUN
if self.ui.radioButton.isChecked():
if self.ui.radioButton_2.isChecked():
if not self.exceeds:
range_min = (self.ui.spinBox.value()-1)*84
range_max = range_min + 84
self.plot_spaceOff.plotMinusLeastSquares(1, self.runProcessor.offsets[range_min:range_max], self.runProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.runProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.runProcessor.secondsPure[range_max])
self.ui.textEdit_2.setText(smallText)
else:
range_min = (self.ui.spinBox.value()-1)*84
range_max = (self.ui.spinBox.value()*84)
if(self.ui.spinBox.value() == self.numberOFTicks):
range_max = range_min + self.exceeds
self.plot_spaceOff.plotMinusLeastSquares(1, self.runProcessor.offsets[range_min:range_max], self.runProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.runProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.runProcessor.secondsPure[range_max-1])
self.ui.textEdit_2.setText(smallText)
else:
if not self.exceeds:
range_min = (self.ui.spinBox.value()-1)*84
range_max = range_min + 84
self.plot_spaceOff.update_plot(1, self.runProcessor.offsets[range_min:range_max], self.runProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.runProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.runProcessor.secondsPure[range_max])
self.ui.textEdit_2.setText(smallText)
else:
range_min = (self.ui.spinBox.value()-1)*84
range_max = (self.ui.spinBox.value()*84)
if(self.ui.spinBox.value() == self.numberOFTicks):
range_max = range_min + self.exceeds
self.plot_spaceOff.update_plot(1, self.runProcessor.offsets[range_min:range_max], self.runProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.runProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.runProcessor.secondsPure[range_max-1])
self.ui.textEdit_2.setText(smallText)
else:
if self.ui.radioButton_2.isChecked():
self.plot_spaceOff.plotMinusLeastSquares(1, self.runProcessor.offsets, self.runProcessor.seconds, av=None, error=None, timeS=None, tickCorrect=0)
smallText = "Initial Time:" + "\n" + ctime(self.runProcessor.secondsPure[0]) + "\n" +\
"Final Time:" + "\n" + ctime(self.runProcessor.secondsPure[-1])
self.ui.textEdit_2.setText(smallText)
else:
self.plot_spaceOff.update_plot(1, self.runProcessor.offsets, self.runProcessor.seconds, av=None, error=None, timeS=None, tickCorrect=0)
smallText = "Initial Time:" + "\n" + ctime(self.runProcessor.secondsPure[0]) + "\n" +\
"Final Time:" + "\n" + ctime(self.runProcessor.secondsPure[-1])
self.ui.textEdit_2.setText(smallText)
elif(self.type == 3): #LOG
self.ui.textEdit_2.clear()
if self.ui.radioButton.isChecked():
if self.ui.radioButton_2.isChecked():
if not self.exceeds:
range_min = (self.ui.spinBox.value()-1)*84
range_max = range_min + 84
self.plot_spaceOff.plotMinusLeastSquares(1, self.logProcessor.offsets[range_min:range_max], self.logProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.logProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.logProcessor.secondsPure[range_max])
self.ui.textEdit_2.setText(smallText)
else:
range_min = (self.ui.spinBox.value()-1)*84
range_max = (self.ui.spinBox.value()*84)
if(self.ui.spinBox.value() == self.numberOFTicks):
range_max = range_min + self.exceeds
self.plot_spaceOff.plotMinusLeastSquares(1, self.logProcessor.offsets[range_min:range_max], self.logProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.logProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.logProcessor.secondsPure[range_max-1])
self.ui.textEdit_2.setText(smallText)
else:
if not self.exceeds:
range_min = (self.ui.spinBox.value()-1)*84
range_max = range_min + 84
self.plot_spaceOff.update_plot(1, self.logProcessor.offsets[range_min:range_max], self.logProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.logProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.logProcessor.secondsPure[range_max])
self.ui.textEdit_2.setText(smallText)
else:
range_min = (self.ui.spinBox.value()-1)*84
range_max = (self.ui.spinBox.value()*84)
if(self.ui.spinBox.value() == self.numberOFTicks):
range_max = range_min + self.exceeds
self.plot_spaceOff.update_plot(1, self.logProcessor.offsets[range_min:range_max], self.logProcessor.seconds[range_min:range_max], av=None, error=None, timeS=None, tickCorrect=1)
smallText = "Initial Time:" + "\n" + ctime(self.logProcessor.secondsPure[range_min]) + "\n" +\
"Final Time:" + "\n" + ctime(self.logProcessor.secondsPure[range_max-1])
self.ui.textEdit_2.setText(smallText)
else:
if self.ui.radioButton_2.isChecked():
self.plot_spaceOff.plotMinusLeastSquares(1, self.logProcessor.offsets, self.logProcessor.seconds, av=None, error=None, timeS=None, tickCorrect=0)
smallText = "Initial Time:" + "\n" + ctime(self.logProcessor.secondsPure[0]) + "\n" +\
"Final Time:" + "\n" + ctime(self.logProcessor.secondsPure[-1])
self.ui.textEdit_2.setText(smallText)
else:
self.plot_spaceOff.update_plot(1, self.logProcessor.offsets, self.logProcessor.seconds, av=None, error=None, timeS=None, tickCorrect=0)
smallText = "Initial Time:" + "\n" + ctime(self.logProcessor.secondsPure[0]) + "\n" +\
"Final Time:" + "\n" + ctime(self.logProcessor.secondsPure[-1])
self.ui.textEdit_2.setText(smallText)
elif self.ui.tabWidget.currentIndex()==2: # Allan Deviations
if(self.type ==1): # LOOPSTATS
if self.ui.radioButton_3.isChecked():
self.plot_spaceAllan.plotAllanPPM(2, off=None, sec=None, av=self.loopProcessor.av, error=self.loopProcessor.error, timeS=self.loopProcessor.timeS, tickCorrect=0)
smallText = 'tau' + "\t" + "Adev" + "\n"
smallText += "-------------------------\n"
for i in range(0,len(self.loopProcessor.timeS)):
smallText += str(self.loopProcessor.timeS[i]) + "\t" + str(self.loopProcessor.av[i]*1e6) + "\n"
self.ui.textEdit_3.setText(smallText)
else:
self.plot_spaceAllan.update_plot(2, off=None, sec=None, av=self.loopProcessor.av, error=self.loopProcessor.error, timeS=self.loopProcessor.timeS, tickCorrect=0)
smallText = 'tau' + "\t" + "Adev" + "\n"
smallText += "-------------------------\n"
for i in range(0,len(self.loopProcessor.timeS)):
smallText += str(self.loopProcessor.timeS[i]) + "\t" + str(self.loopProcessor.av[i]) + "\n"
self.ui.textEdit_3.setText(smallText)
elif(self.type == 2): #RUN
if self.ui.radioButton_3.isChecked():
self.plot_spaceAllan.plotAllanPPM(2, off=None, sec=None, av=self.runProcessor.av, error=self.runProcessor.error, timeS=self.runProcessor.timeS, tickCorrect=0)
smallText = 'tau' + "\t" + "Adev" + "\n"
smallText += "-------------------------\n"
for i in range(0,len(self.runProcessor.timeS)):
smallText += str(self.runProcessor.timeS[i]) + "\t" + str(self.runProcessor.av[i]*1e6) + "\n"
self.ui.textEdit_3.setText(smallText)
else:
self.plot_spaceAllan.update_plot(2, off=None, sec=None, av=self.runProcessor.av, error=self.runProcessor.error, timeS=self.runProcessor.timeS, tickCorrect=0)
smallText = 'tau' + "\t" + "Adev" + "\n"
smallText += "-------------------------\n"
for i in range(0,len(self.runProcessor.timeS)):
smallText += str(self.runProcessor.timeS[i]) + "\t" + str(self.runProcessor.av[i]) + "\n"
self.ui.textEdit_3.setText(smallText)
elif(self.type==3): # LOG
if self.ui.radioButton_3.isChecked():
self.plot_spaceAllan.plotAllanPPM(2, off=None, sec=None, av=self.logProcessor.av, error=self.logProcessor.error, timeS=self.logProcessor.timeS, tickCorrect=0)
smallText = 'tau' + "\t" + "Adev" + "\n"
smallText += "-------------------------\n"
for i in range(0,len(self.logProcessor.timeS)):
smallText += str(self.logProcessor.timeS[i]) + "\t" + str(self.logProcessor.av[i]*1e6) + "\n"
self.ui.textEdit_3.setText(smallText)
else:
self.plot_spaceAllan.update_plot(2, off=None, sec=None, av=self.logProcessor.av, error=self.logProcessor.error, timeS=self.logProcessor.timeS, tickCorrect=0)
smallText = 'tau' + "\t" + "Adev" + "\n"
smallText += "-------------------------\n"
for i in range(0,len(self.logProcessor.timeS)):
smallText += str(self.logProcessor.timeS[i]) + "\t" + str(self.logProcessor.av[i]) + "\n"
self.ui.textEdit_3.setText(smallText)
elif self.ui.tabWidget.currentIndex()==3: #Histograms
if(self.type == 1): # LOOPSTATS
self.plot_spaceHist.update_plot(3, self.loopProcessor.offsets, sec=None, av=None, error=None, timeS=None, tickCorrect=0)
elif(self.type == 2): #RUN
self.plot_spaceHist.update_plot(3, self.runProcessor.offsets, sec=None, av=None, error=None, timeS=None, tickCorrect=0)
elif(self.type == 3): # LOG
self.plot_spaceHist.update_plot(3, self.logProcessor.offsets, sec=None, av=None, error=None, timeS=None, tickCorrect=0)