def addDock(self, name, widget, area=Qt.LeftDockWidgetArea, allowed_areas=Qt.AllDockWidgetAreas):
dock_widget = QDockWidget(name)
dock_widget.setObjectName("%sDock" % name)
dock_widget.setWidget(widget)
dock_widget.setAllowedAreas(allowed_areas)
dock_widget.setFeatures(QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable)
self.addDockWidget(area, dock_widget)
return dock_widget
def create_dockwidget(self, title):
"""Add to parent QMainWindow as a dock widget"""
dock = QDockWidget(title, self.parent_widget)
dock.setObjectName(self.__class__.__name__ + "_dw")
dock.setAllowedAreas(self._allowed_areas)
dock.setFeatures(self._features)
dock.setWidget(self)
dock.visibilityChanged.connect(self.visibility_changed)
self.dockwidget = dock
return (dock, self._location)
def create_dockwidget(self):
"""Creates a QDockWidget suitable for wrapping
this plugin"""
dock = QDockWidget(self.get_plugin_title(), self.main)
dock.setObjectName(self.__class__.__name__ + "_dockwidget")
dock.setAllowedAreas(self.ALLOWED_AREAS)
dock.setFeatures(self.FEATURES)
dock.setWidget(self)
self.dockwidget = dock
return dock, self.LOCATION
def create_dockwidget(self):
"""Creates a QDockWidget suitable for wrapping
this plugin"""
dock = QDockWidget(self.get_plugin_title(), self.main)
dock.setObjectName(self.__class__.__name__+"_dockwidget")
dock.setAllowedAreas(self.ALLOWED_AREAS)
dock.setFeatures(self.FEATURES)
dock.setWidget(self)
self.dockwidget = dock
return dock, self.LOCATION
def addDock(self,
name,
widget,
area=Qt.RightDockWidgetArea,
allowed_areas=Qt.AllDockWidgetAreas):
dock_widget = QDockWidget(name)
dock_widget.setObjectName("%sDock" % name)
dock_widget.setWidget(widget)
dock_widget.setAllowedAreas(allowed_areas)
self.addDockWidget(area, dock_widget)
self.__view_menu.addAction(dock_widget.toggleViewAction())
return dock_widget
def add_dock_widget(self,
area: str = 'bottom',
widget: QWidget = None,
allowed_areas=None):
"""Convenience method to add a QDockWidget to the main window
Parameters
----------
area : str
Side of the main window to which the new dock widget will be added.
Must be in {'left', 'right', 'top', 'bottom'}
widget : QWidget, optional
If provided, `widget` will be added as QDockWidget's main widget
allowed_areas : Qt.DockWidgetArea, optional
Areas, relative to main window, that the new dock is allowed to go.
"""
areas = {
'left': Qt.LeftDockWidgetArea,
'right': Qt.RightDockWidgetArea,
'top': Qt.TopDockWidgetArea,
'bottom': Qt.BottomDockWidgetArea,
}
if area not in areas:
raise ValueError(f'side argument must be in {list(areas.keys())}')
dock_widget = QDockWidget(self._qt_window)
dock_widget.setAllowedAreas(allowed_areas or (Qt.LeftDockWidgetArea
| Qt.BottomDockWidgetArea
| Qt.RightDockWidgetArea
| Qt.TopDockWidgetArea))
dock_widget.setMinimumHeight(50)
dock_widget.setMinimumWidth(50)
if isinstance(widget, QWidget):
dock_widget.setWidget(widget)
widget.setParent(dock_widget)
self._qt_window.addDockWidget(areas[area], dock_widget)
return dock_widget
def _create_dock_widget(window, name, area, *, max_width=None):
# create dock widget
dock = QDockWidget(name)
# add scroll area
scroll = QScrollArea(dock)
dock.setWidget(scroll)
# give the scroll area a child widget
widget = QWidget(scroll)
scroll.setWidget(widget)
scroll.setWidgetResizable(True)
dock.setAllowedAreas(area)
dock.setTitleBarWidget(QLabel(name))
window.addDockWidget(area, dock)
dock_layout = QVBoxLayout()
widget.setLayout(dock_layout)
# Fix resize grip size
# https://stackoverflow.com/a/65050468/2175965
styles = ['margin: 4px;']
if max_width is not None:
styles.append(f'max-width: {max_width};')
style_sheet = 'QDockWidget { ' + ' \n'.join(styles) + '\n}'
dock.setStyleSheet(style_sheet)
return dock, dock_layout
class FittingPlotView(QtWidgets.QWidget, Ui_plot):
def __init__(self, parent=None):
super(FittingPlotView, self).__init__(parent)
self.setupUi(self)
self.figure = None
self.toolbar = None
self.fitprop_toolbar = None
self.fit_browser = None
self.plot_dock = None
self.dock_window = None
self.setup_figure()
self.setup_toolbar()
def setup_figure(self):
self.figure = Figure()
self.figure.canvas = FigureCanvas(self.figure)
self.figure.canvas.mpl_connect('button_press_event', self.mouse_click)
self.figure.add_subplot(111, projection="mantid")
self.figure.tight_layout()
self.toolbar = FittingPlotToolbar(self.figure.canvas, self, False)
self.toolbar.setMovable(False)
self.dock_window = QMainWindow(self.group_plot)
self.dock_window.setWindowFlags(Qt.Widget)
self.dock_window.setDockOptions(QMainWindow.AnimatedDocks)
self.dock_window.setCentralWidget(self.toolbar)
self.plot_dock = QDockWidget()
self.plot_dock.setWidget(self.figure.canvas)
self.plot_dock.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.plot_dock.setAllowedAreas(Qt.BottomDockWidgetArea)
self.plot_dock.setWindowTitle("Fit Plot")
self.dock_window.addDockWidget(Qt.BottomDockWidgetArea, self.plot_dock)
self.vLayout_plot.addWidget(self.dock_window)
self.fit_browser = EngDiffFitPropertyBrowser(
self.figure.canvas, ToolbarStateManager(self.toolbar))
# remove SequentialFit from fit menu (implemented a different way)
qmenu = self.fit_browser.getFitMenu()
qmenu.removeAction([
qact for qact in qmenu.actions() if qact.text() == "Sequential Fit"
][0])
# hide unnecessary properties of browser
hide_props = [
'StartX', 'EndX', 'Minimizer', 'Cost function', 'Max Iterations',
'Output', 'Ignore invalid data', 'Peak Radius',
'Plot Composite Members', 'Convolve Composite Members',
'Show Parameter Errors', 'Evaluate Function As'
]
self.fit_browser.removePropertiesFromSettingsBrowser(hide_props)
self.fit_browser.toggleWsListVisible()
self.fit_browser.closing.connect(self.toolbar.handle_fit_browser_close)
self.vLayout_fitprop.addWidget(self.fit_browser)
self.fit_browser.hide()
def mouse_click(self, event):
if event.button == event.canvas.buttond.get(Qt.RightButton):
menu = QMenu()
self.fit_browser.add_to_menu(menu)
menu.exec_(QCursor.pos())
def resizeEvent(self, QResizeEvent):
self.figure.tight_layout()
def ensure_fit_dock_closed(self):
if self.plot_dock.isFloating():
self.plot_dock.close()
def setup_toolbar(self):
self.toolbar.sig_home_clicked.connect(self.display_all)
self.toolbar.sig_toggle_fit_triggered.connect(self.fit_toggle)
# =================
# Component Setters
# =================
def fit_toggle(self):
"""Toggle fit browser and tool on/off"""
if self.fit_browser.isVisible():
self.fit_browser.hide()
else:
self.fit_browser.show()
def clear_figure(self):
self.figure.clf()
self.figure.add_subplot(111, projection="mantid")
self.figure.tight_layout()
self.figure.canvas.draw()
def update_figure(self):
self.toolbar.update()
self.figure.tight_layout()
self.update_legend(self.get_axes()[0])
self.figure.canvas.draw()
self.update_fitbrowser()
def update_fitbrowser(self):
is_visible = self.fit_browser.isVisible()
self.toolbar.set_fit_checkstate(False)
self.fit_browser.hide()
if self.fit_browser.getWorkspaceNames() and is_visible:
self.toolbar.set_fit_checkstate(True)
self.fit_browser.show()
def remove_ws_from_fitbrowser(self, ws):
# only one spectra per workspace
self.fit_browser.removeWorkspaceAndSpectra(ws.name())
def update_legend(self, ax):
if ax.get_lines():
ax.make_legend()
ax.get_legend().set_title("")
else:
if ax.get_legend():
ax.get_legend().remove()
def display_all(self):
for ax in self.get_axes():
if ax.lines:
ax.relim()
ax.autoscale()
self.update_figure()
def read_fitprop_from_browser(self):
return self.fit_browser.read_current_fitprop()
def update_browser(self, status, func_str, setup_name):
self.fit_browser.fitResultsChanged.emit(status)
self.fit_browser.changeWindowTitle.emit(status)
# update browser with output function and save setup if successful
if "success" in status.lower():
self.fit_browser.loadFunction(func_str)
self.fit_browser.save_current_setup(setup_name)
# =================
# Component Getters
# =================
def get_axes(self):
return self.figure.axes
def get_figure(self):
return self.figure
class MainWindow(QMainWindow):
def __init__(self, argv):
super(MainWindow, self).__init__()
self.main_widget = None
self.graphic_settings_dock = None
self.zero_loss_peak_dock = None
self.projects_dock = None
self.spectra = Spectra()
self.init_ui()
self.read_settings()
self.parse_arguments(argv)
def init_ui(self):
# Define standard icon.
standard_icon = self.style().standardIcon
# Central widget.
self.main_widget = SpectrumWidget(self.spectra)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
# Open spectrum action
open_spectrum_action = QAction(standard_icon(QStyle.SP_DialogOpenButton), 'Open spectrum', self)
open_spectrum_action.setShortcut('Ctrl+O')
open_spectrum_action.setStatusTip('Open spectrum')
open_spectrum_action.triggered.connect(self.open_spectrum)
# Exit action
exit_action = QAction(standard_icon(QStyle.SP_TitleBarCloseButton), 'Exit', self)
exit_action.setShortcut('Ctrl+Q')
exit_action.setStatusTip('Exit application')
exit_action.triggered.connect(self.close)
# Status bar.
self.statusBar()
# Menu bar.
menubar = self.menuBar()
file_menu = menubar.addMenu('&File')
file_menu.addAction(open_spectrum_action)
file_menu.addAction(exit_action)
view_menu = menubar.addMenu('&View')
analysis_menu = menubar.addMenu('&Analysis')
# Toolbar
file_toolbar = self.addToolBar('File')
file_toolbar.addAction(open_spectrum_action)
file_toolbar.addAction(exit_action)
view_menu.addAction(file_toolbar.toggleViewAction())
analysis_toolbar = self.addToolBar('Analysis')
view_menu.addAction(analysis_toolbar.toggleViewAction())
view_menu.addSeparator()
# Dock widget.
self.graphic_settings_dock = QDockWidget("Graphic settings", self)
self.graphic_settings_dock.setObjectName("graphic_settings_dock")
self.graphic_settings_dock.setAllowedAreas(Qt.AllDockWidgetAreas)
label_test = QLabel("Test label")
self.graphic_settings_dock.setWidget(label_test)
view_menu.addAction(self.graphic_settings_dock.toggleViewAction())
self.addDockWidget(Qt.AllDockWidgetAreas, self.graphic_settings_dock)
print(self.graphic_settings_dock.objectName())
self.zero_loss_peak_dock = ZeroLossPeakWidget(self, self.spectra)
analysis_menu.addAction(self.zero_loss_peak_dock.toggleViewAction())
self.addDockWidget(Qt.AllDockWidgetAreas, self.zero_loss_peak_dock)
self.projects_dock = ProjectWidget(self)
view_menu.addAction(self.projects_dock.toggleViewAction())
self.addDockWidget(Qt.AllDockWidgetAreas, self.projects_dock)
# Final options.
self.setWindowTitle('pySEM-EELS')
self.show()
def closeEvent(self, event):
self.save_settings()
super(MainWindow, self).closeEvent(event)
def save_settings(self):
settings = QSettings("openMicroanalysis", "pysemeelsgui")
# print(settings.fileName())
settings.beginGroup("MainWindow")
settings.setValue("geometry", self.saveGeometry())
settings.setValue("window_state", self.saveState())
settings.endGroup()
settings.beginGroup("graphic_settings_dock")
settings.setValue("visible", self.graphic_settings_dock.isVisible())
settings.endGroup()
settings.beginGroup("zero_loss_peak_dock")
settings.setValue("visible", self.zero_loss_peak_dock.isVisible())
settings.endGroup()
settings.beginGroup("projects_dock")
settings.setValue("visible", self.projects_dock.isVisible())
settings.endGroup()
def read_settings(self):
settings = QSettings("openMicroanalysis", "pysemeelsgui")
# print(settings.fileName())
# settings.clear()
settings.beginGroup("MainWindow")
geometry_value = settings.value("geometry")
if geometry_value is None:
self.setGeometry(300, 300, 600, 400)
else:
self.restoreGeometry(geometry_value)
window_state_value = settings.value("window_state")
if window_state_value is not None:
self.restoreState(window_state_value)
settings.endGroup()
settings.beginGroup("graphic_settings_dock")
visible_value = settings.value("visible")
if visible_value is not None:
if visible_value == "true":
self.graphic_settings_dock.setVisible(True)
elif visible_value == "false":
self.graphic_settings_dock.setVisible(False)
settings.endGroup()
settings.beginGroup("zero_loss_peak_dock")
visible_value = settings.value("visible")
if visible_value is not None:
if visible_value == "true":
self.zero_loss_peak_dock.setVisible(True)
elif visible_value == "false":
self.zero_loss_peak_dock.setVisible(False)
settings.endGroup()
def parse_arguments(self, argv):
option_parser = optparse.OptionParser()
option_parser.add_option("-s", "--spectrum", action="store", type="string", dest="spectrum_file", help="Open a eels spectrum")
options, arguments = option_parser.parse_args()
logging.info("Remaining arguments: {}".format(arguments))
logging.info("Spectrum file: {}".format(options.spectrum_file))
if options.spectrum_file:
self.spectra.open_spectrum(options.spectrum_file)
elv_file = self.spectra.get_current_elv_file()
spectrum_data = elv_file.get_spectrum_data()
self.main_widget.update_figure(spectrum_data)
def open_spectrum(self):
self.statusBar().showMessage("Opening spectrum", 2000)
path = os.path.dirname(__file__)
formats = ["*.elv"]
spectrum_filter = "Spectrum file ({:s})".format(" ".join(formats))
file_names = QFileDialog.getOpenFileName(self, "Open an EELS spectrum", path, spectrum_filter)
self.spectra.open_spectrum(file_names)
elv_file = self.spectra.get_current_elv_file()
spectrum_data = elv_file.get_spectrum_data()
self.main_widget.update_figure(spectrum_data)
class MainWindow(QMainWindow):
def __init__(self):
self.logger = logging.getLogger(APPLICATION_NAME + '.MainWindow')
self.logger.info("MainWindow.__init__")
super(MainWindow, self).__init__()
self.init_ui()
self.read_settings()
def init_ui(self):
# Define standard icon.
standard_icon = self.style().standardIcon
# Central widget.
self.main_widget = SpectrumWidget()
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
# Project action
new_project_action = QAction(QIcon(':/oi/svg/document.svg'),
'New project', self)
new_project_action.setShortcut('Ctrl+N')
new_project_action.setStatusTip('New project')
new_project_action.triggered.connect(self.new_project)
open_project_action = QAction(QIcon(':/oi/svg/envelope-open.svg'),
'Open project', self)
open_project_action.setShortcut('Ctrl+O')
open_project_action.setStatusTip('Open project')
open_project_action.triggered.connect(self.open_project)
close_project_action = QAction(QIcon(':/oi/svg/envelope-closed.svg'),
'Close project', self)
close_project_action.setShortcut('Ctrl+C')
close_project_action.setStatusTip('Close project')
close_project_action.triggered.connect(self.close_project)
save_project_action = QAction(QIcon(':/oi/svg/hard-drive.svg'),
'Save project', self)
save_project_action.setShortcut('Ctrl+S')
save_project_action.setStatusTip('Save project')
save_project_action.triggered.connect(self.save_project)
saveas_project_action = QAction(QIcon(':/oi/svg/hard-drive.svg'),
'Save project as ...', self)
# saveas_project_action.setShortcut('Ctrl+S')
saveas_project_action.setStatusTip('Save project as ...')
saveas_project_action.triggered.connect(self.saveas_project)
# Spectrum action
import_spectrum_action = QAction(QIcon(':/oi/svg/account-login.svg'),
'Import spectrum', self)
import_spectrum_action.setShortcut('Ctrl+I')
import_spectrum_action.setStatusTip('Import spectrum')
import_spectrum_action.triggered.connect(self.import_spectrum)
export_spectrum_action = QAction(QIcon(':/oi/svg/account-logout.svg'),
'Export spectrum', self)
# export_spectrum_action.setShortcut('Ctrl+I')
export_spectrum_action.setStatusTip('Export spectrum')
export_spectrum_action.triggered.connect(self.export_spectrum)
# Exit action
exit_action = QAction(QIcon(':/oi/svg/x.svg'), 'Exit', self)
exit_action.setShortcut('Ctrl+Q')
exit_action.setStatusTip('Exit application')
exit_action.triggered.connect(self.close)
# Status bar.
self.statusBar()
# Menu bar.
menubar = self.menuBar()
file_menu = menubar.addMenu('&File')
file_menu.addAction(new_project_action)
file_menu.addAction(open_project_action)
file_menu.addAction(save_project_action)
file_menu.addAction(saveas_project_action)
file_menu.addAction(close_project_action)
file_menu.addSeparator()
file_menu.addAction(exit_action)
view_menu = menubar.addMenu('&View')
spectrum_menu = menubar.addMenu('&Spectrum')
spectrum_menu.addAction(import_spectrum_action)
analysis_menu = menubar.addMenu('&Analysis')
# Toolbar
file_toolbar = self.addToolBar('File')
file_toolbar.addAction(new_project_action)
file_toolbar.addAction(open_project_action)
file_toolbar.addAction(save_project_action)
file_toolbar.addAction(saveas_project_action)
file_toolbar.addAction(close_project_action)
file_toolbar.addAction(exit_action)
view_menu.addAction(file_toolbar.toggleViewAction())
spectrum_toolbar = self.addToolBar('Spectrum')
spectrum_toolbar.addAction(import_spectrum_action)
view_menu.addAction(spectrum_toolbar.toggleViewAction())
analysis_toolbar = self.addToolBar('Analysis')
view_menu.addAction(analysis_toolbar.toggleViewAction())
view_menu.addSeparator()
# Dock widget.
self.graphic_settings_dock = QDockWidget("Graphic settings", self)
self.graphic_settings_dock.setObjectName("graphic_settings_dock")
self.graphic_settings_dock.setAllowedAreas(Qt.AllDockWidgetAreas)
label_test = QLabel("Test label")
self.graphic_settings_dock.setWidget(label_test)
view_menu.addAction(self.graphic_settings_dock.toggleViewAction())
self.addDockWidget(Qt.AllDockWidgetAreas, self.graphic_settings_dock)
print(self.graphic_settings_dock.objectName())
# Final options.
self.setWindowTitle('X-ray spectrum analyzer')
self.show()
def closeEvent(self, event):
self.save_settings()
super(MainWindow, self).closeEvent(event)
def save_settings(self):
settings = QSettings("openMicroanalysis", "xrayspectrumanalyzergui")
# print(settings.fileName())
settings.beginGroup("MainWindow")
settings.setValue("geometry", self.saveGeometry())
settings.setValue("window_state", self.saveState())
settings.endGroup()
settings.beginGroup("graphic_settings_dock")
settings.setValue("visible", self.graphic_settings_dock.isVisible())
settings.endGroup()
# settings.beginGroup("zero_loss_peak_dock")
# settings.setValue("visible", self.zero_loss_peak_dock.isVisible())
# settings.endGroup()
def read_settings(self):
settings = QSettings("openMicroanalysis", "xrayspectrumanalyzergui")
# print(settings.fileName())
# settings.clear()
settings.beginGroup("MainWindow")
geometry_value = settings.value("geometry")
if geometry_value is None:
self.setGeometry(300, 300, 600, 400)
else:
self.restoreGeometry(geometry_value)
window_state_value = settings.value("window_state")
if window_state_value is not None:
self.restoreState(window_state_value)
settings.endGroup()
settings.beginGroup("graphic_settings_dock")
visible_value = settings.value("visible")
if visible_value is not None:
if visible_value == "true":
self.graphic_settings_dock.setVisible(True)
elif visible_value == "false":
self.graphic_settings_dock.setVisible(False)
settings.endGroup()
# settings.beginGroup("zero_loss_peak_dock")
# visible_value = settings.value("visible")
# if visible_value is not None:
# if visible_value == "true":
# self.zero_loss_peak_dock.setVisible(True)
# elif visible_value == "false":
# self.zero_loss_peak_dock.setVisible(False)
# settings.endGroup()
def import_spectrum(self):
self.statusBar().showMessage("Import spectrum", 2000)
path = os.path.dirname(__file__)
formats = ["*.msa", "*.txt"]
file_filters = "Spectrum file ({:s})".format(" ".join(formats))
file_names = QFileDialog.getOpenFileName(self,
"Import an x-ray spectrum",
path, file_filters)
def export_spectrum(self):
self.statusBar().showMessage("Export spectrum", 2000)
def new_project(self):
self.statusBar().showMessage("New project", 2000)
def open_project(self):
self.statusBar().showMessage("Open project", 2000)
def close_project(self):
self.statusBar().showMessage("Close project", 2000)
def save_project(self):
self.statusBar().showMessage("Save project", 2000)
def saveas_project(self):
self.statusBar().showMessage("Save project as ...", 2000)
def create_gui(self):
self.logger.info("MainWindow.create_gui")
self._create_main_window()
self._create_actions()
self._create_menus()
self._create_toolbars()
self._create_tooltip()
self._create_spectra_display()
self._create_data_display()
self._create_operations_display()
self._create_layout()
self._create_statusbar()
self._read_settings()
self.show()
def _create_main_window(self):
self.setGeometry(300, 300, 500, 500)
self.setWindowTitle('Spectrum Analyzer')
# self.setWindowIcon(QIcon('../../../images/cog.svg'))
self.setWindowIcon(self.style().standardIcon(QStyle.SP_DesktopIcon))
self._center_main_window()
def _center_main_window(self):
self.logger.info("MainWindow._center_main_window")
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def _create_menus(self):
self.logger.info("MainWindow._create_menus")
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction(self.newAct)
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addAction(self.saveAsAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitAct)
self.menuBar().addSeparator()
self.helpMenu = self.menuBar().addMenu("&Help")
self.helpMenu.addAction(self.aboutAct)
self.helpMenu.addAction(self.aboutQtAct)
def _create_layout(self):
mainLayout = QHBoxLayout()
mainLayout.addWidget(self.dataGroupBox)
mainLayout.addWidget(self.plotGroupBox)
mainLayout.addWidget(self.operationsGroupBox)
self.mainGroupBox = QGroupBox("Main layout")
self.mainGroupBox.setLayout(mainLayout)
self.setCentralWidget(self.mainGroupBox)
def _create_spectra_display(self):
self.plotGroupBox = QGroupBox("Plot layout")
self.figure1 = Figure(facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
self.canvas1 = FigureCanvas(self.figure1)
self.canvas1.setParent(self.plotGroupBox)
self.canvas1.setFocusPolicy(Qt.StrongFocus)
self.canvas1.setFocus()
self.canvas1.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.canvas1.updateGeometry()
self.mpl_toolbar1 = NavigationToolbar(self.canvas1, self.plotGroupBox)
self.canvas1.mpl_connect('key_press_event', self.on_key_press)
self.figure2 = Figure(facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
self.canvas2 = FigureCanvas(self.figure2)
self.canvas2.setParent(self.plotGroupBox)
self.mpl_toolbar2 = NavigationToolbar(self.canvas1, self.plotGroupBox)
layout = QVBoxLayout()
layout.addWidget(self.canvas1)
layout.addWidget(self.mpl_toolbar1)
layout.addWidget(self.canvas2)
layout.addWidget(self.mpl_toolbar2)
self.plotGroupBox.setLayout(layout)
def _create_data_display(self):
self.dataGroupBox = QGroupBox("Data layout")
data_layout = QVBoxLayout()
group_box = QGroupBox("Spectra")
self.spectra_list_view = QListWidget(self)
self.spectra_list_view.setMinimumWidth(200)
layout = QVBoxLayout()
layout.addWidget(self.spectra_list_view)
group_box.setLayout(layout)
data_layout.addWidget(group_box)
group_box = QGroupBox("ROI")
roi_list_view = QListWidget(self)
layout = QVBoxLayout()
layout.addWidget(roi_list_view)
group_box.setLayout(layout)
data_layout.addWidget(group_box)
group_box = QGroupBox("Elements")
element_list_view = QListWidget(self)
layout = QVBoxLayout()
layout.addWidget(element_list_view)
group_box.setLayout(layout)
data_layout.addWidget(group_box)
self.dataGroupBox.setLayout(data_layout)
def _create_operations_display(self):
self.operationsGroupBox = QGroupBox("Operations layout")
results_layout = QVBoxLayout()
group_box = QGroupBox("Operation")
results_layout.addWidget(group_box)
group_box = QGroupBox("Results")
results_layout.addWidget(group_box)
self.operationsGroupBox.setLayout(results_layout)
def _create_tooltip(self):
QToolTip.setFont(QFont('SansSerif', 10))
self.setToolTip('This is a <b>QWidget</b> widget')
def _create_actions(self):
self.logger.info("MainWindow._create_actions")
self.newAct = QAction(self.style().standardIcon(QStyle.SP_FileIcon),
"&New",
self,
shortcut=QKeySequence.New,
statusTip="Create a new file",
triggered=self.newFile)
self.openAct = QAction(self.style().standardIcon(
QStyle.SP_DirOpenIcon),
"&Open...",
self,
shortcut=QKeySequence.Open,
statusTip="Open an existing file",
triggered=self.open)
self.saveAct = QAction(self.style().standardIcon(
QStyle.SP_DialogSaveButton),
"&Save",
self,
shortcut=QKeySequence.Save,
statusTip="Save the document to disk",
triggered=self.save)
self.saveAsAct = QAction(
self.style().standardIcon(QStyle.SP_DialogSaveButton),
"Save &As...",
self,
shortcut=QKeySequence.SaveAs,
statusTip="Save the document under a new name",
triggered=self.saveAs)
self.exitAct = QAction(self.style().standardIcon(
QStyle.SP_DialogCloseButton),
"E&xit",
self,
shortcut="Ctrl+Q",
statusTip="Exit the application",
triggered=self.close)
self.textEdit = QTextEdit()
self.aboutAct = QAction(self.style().standardIcon(
QStyle.SP_MessageBoxInformation),
"&About",
self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QAction(self.style().standardIcon(
QStyle.SP_TitleBarMenuButton),
"About &Qt",
self,
statusTip="Show the Qt library's About box",
triggered=QApplication().aboutQt)
def _create_toolbars(self):
self.logger.info("MainWindow._create_toolbars")
self.fileToolBar = self.addToolBar("File")
self.fileToolBar.addAction(self.newAct)
self.fileToolBar.addAction(self.openAct)
self.fileToolBar.addAction(self.saveAct)
def _create_statusbar(self):
self.logger.info("MainWindow._create_statusbar")
self.statusBar().showMessage("Ready")
def _read_settings(self):
self.logger.info("MainWindow._read_settings")
settings = QSettings(ORGANIZATION_NAME, APPLICATION_NAME)
pos = settings.value("pos", QPoint(200, 200))
size = settings.value("size", QSize(400, 400))
self.resize(size)
self.move(pos)
def _write_settings(self):
self.logger.info("MainWindow._write_settings")
settings = QSettings(ORGANIZATION_NAME, APPLICATION_NAME)
settings.setValue("pos", self.pos())
settings.setValue("size", self.size())
def maybeSave(self):
self.logger.info("MainWindow.maybeSave")
if self.textEdit.document().isModified():
ret = QMessageBox.warning(
self, "Application",
"The document has been modified.\nDo you want to save "
"your changes?",
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
if ret == QMessageBox.Save:
return self.save()
elif ret == QMessageBox.Cancel:
return False
return True
def closeEvent(self, event):
self.logger.info("MainWindow.closeEvent")
if self.maybeSave():
self._write_settings()
event.accept()
else:
event.ignore()
def newFile(self):
self.logger.info("MainWindow.newFile")
if self.maybeSave():
self.textEdit.clear()
self.setCurrentFile('')
def open(self):
self.logger.info("MainWindow.open")
if self.maybeSave():
filepath, _filtr = QFileDialog.getOpenFileName(self)
if filepath:
self.spectrumAnalyzer.readSpectrum(filepath)
filename = os.path.basename(filepath)
self.spectra_list_view.addItem(filename)
self.spectrumAnalyzer.plotSpectrum(self.figure1)
self.canvas1.draw()
def save(self):
self.logger.info("MainWindow.save")
if self.curFile:
return self.saveFile(self.curFile)
return self.saveAs()
def saveAs(self):
self.logger.info("MainWindow.saveAs")
fileName, _filtr = QFileDialog.getSaveFileName(self)
if fileName:
return self.saveFile(fileName)
return False
def about(self):
self.logger.info("MainWindow.about")
QMessageBox.about(
self, "About xrayspectrumanalyzer",
"The <b>xrayspectrumanalyzer</b> extract peak intensity from EDS spectrum."
)
def documentWasModified(self):
self.logger.info("MainWindow.documentWasModified")
self.setWindowModified(self.textEdit.document().isModified())
def on_key_press(self, event):
print('you pressed', event.key)
# implement the default mpl key press events described at
# http://matplotlib.org/users/navigation_toolbar.html#navigation-keyboard-shortcuts
key_press_handler(event, self.canvas1, self.mpl_toolbar1)
class FittingPlotView(QtWidgets.QWidget, Ui_plot):
def __init__(self, parent=None):
super(FittingPlotView, self).__init__(parent)
self.setupUi(self)
self.figure = None
self.toolbar = None
self.fitprop_toolbar = None
self.fit_browser = None
self.plot_dock = None
self.dock_window = None
self.initial_chart_width = None
self.initial_chart_height = None
self.has_first_undock_occurred = 0
self.setup_figure()
self.setup_toolbar()
def setup_figure(self):
self.figure = Figure()
self.figure.canvas = FigureCanvas(self.figure)
self.figure.canvas.mpl_connect('button_press_event', self.mouse_click)
self.figure.add_subplot(111, projection="mantid")
self.toolbar = FittingPlotToolbar(self.figure.canvas, self, False)
self.toolbar.setMovable(False)
self.dock_window = QMainWindow(self.group_plot)
self.dock_window.setWindowFlags(Qt.Widget)
self.dock_window.setDockOptions(QMainWindow.AnimatedDocks)
self.dock_window.setCentralWidget(self.toolbar)
self.plot_dock = QDockWidget()
self.plot_dock.setWidget(self.figure.canvas)
self.plot_dock.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.plot_dock.setAllowedAreas(Qt.BottomDockWidgetArea)
self.plot_dock.setWindowTitle("Fit Plot")
self.plot_dock.topLevelChanged.connect(self.make_undocked_plot_larger)
self.initial_chart_width, self.initial_chart_height = self.plot_dock.width(
), self.plot_dock.height()
self.plot_dock.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.dock_window.addDockWidget(Qt.BottomDockWidgetArea, self.plot_dock)
self.vLayout_plot.addWidget(self.dock_window)
self.fit_browser = EngDiffFitPropertyBrowser(
self.figure.canvas, ToolbarStateManager(self.toolbar))
# remove SequentialFit from fit menu (implemented a different way)
qmenu = self.fit_browser.getFitMenu()
qmenu.removeAction([
qact for qact in qmenu.actions() if qact.text() == "Sequential Fit"
][0])
# hide unnecessary properties of browser
hide_props = [
'Minimizer', 'Cost function', 'Max Iterations', 'Output',
'Ignore invalid data', 'Peak Radius', 'Plot Composite Members',
'Convolve Composite Members', 'Show Parameter Errors',
'Evaluate Function As'
]
self.fit_browser.removePropertiesFromSettingsBrowser(hide_props)
self.fit_browser.toggleWsListVisible()
self.fit_browser.closing.connect(self.toolbar.handle_fit_browser_close)
self.vLayout_fitprop.addWidget(self.fit_browser)
self.fit_browser.hide()
def mouse_click(self, event):
if event.button == event.canvas.buttond.get(Qt.RightButton):
menu = QMenu()
self.fit_browser.add_to_menu(menu)
menu.exec_(QCursor.pos())
def resizeEvent(self, QResizeEvent):
self.update_axes_position()
def make_undocked_plot_larger(self):
# only make undocked plot larger the first time it is undocked as the undocked size gets remembered
if self.plot_dock.isFloating() and self.has_first_undock_occurred == 0:
factor = 1.0
aspect_ratio = self.initial_chart_width / self.initial_chart_height
new_height = self.initial_chart_height * factor
docked_height = self.dock_window.height()
if docked_height > new_height:
new_height = docked_height
new_width = new_height * aspect_ratio
self.plot_dock.resize(new_width, new_height)
self.has_first_undock_occurred = 1
self.update_axes_position()
def ensure_fit_dock_closed(self):
if self.plot_dock.isFloating():
self.plot_dock.close()
def setup_toolbar(self):
self.toolbar.sig_home_clicked.connect(self.display_all)
self.toolbar.sig_toggle_fit_triggered.connect(self.fit_toggle)
# =================
# Component Setters
# =================
def fit_toggle(self):
"""Toggle fit browser and tool on/off"""
if self.fit_browser.isVisible():
self.fit_browser.hide()
else:
self.fit_browser.show()
def clear_figure(self):
self.figure.clf()
self.figure.add_subplot(111, projection="mantid")
self.figure.canvas.draw()
def update_figure(self):
self.toolbar.update()
self.update_legend(self.get_axes()[0])
self.update_axes_position()
self.figure.canvas.draw()
self.update_fitbrowser()
def update_axes_position(self):
"""
Set axes position so that labels are always visible - it deliberately ignores height of ylabel (and less
importantly the length of xlabel). This is because the plot window typically has a very small height when docked
in the UI.
"""
ax = self.get_axes()[0]
y0_lab = ax.xaxis.get_tightbbox(
renderer=self.figure.canvas.get_renderer()
).transformed(
self.figure.transFigure.inverted()
).y0 # vertical coord of bottom left corner of xlabel in fig ref. frame
x0_lab = ax.yaxis.get_tightbbox(
renderer=self.figure.canvas.get_renderer()
).transformed(
self.figure.transFigure.inverted()
).x0 # horizontal coord of bottom left corner ylabel in fig ref. frame
pos = ax.get_position()
x0_ax = pos.x0 + 0.05 - x0_lab # move so that ylabel left bottom corner at horizontal coord 0.05
y0_ax = pos.y0 + 0.05 - y0_lab # move so that xlabel left bottom corner at vertical coord 0.05
ax.set_position([x0_ax, y0_ax, 0.95 - x0_ax, 0.95 - y0_ax])
def update_fitbrowser(self):
is_visible = self.fit_browser.isVisible()
self.toolbar.set_fit_checkstate(False)
self.fit_browser.hide()
if self.fit_browser.getWorkspaceNames() and is_visible:
self.toolbar.set_fit_checkstate(True)
self.fit_browser.show()
def remove_ws_from_fitbrowser(self, ws):
# only one spectra per workspace
try:
self.fit_browser.removeWorkspaceAndSpectra(ws.name())
except:
pass # name may not be available if ws has just been deleted
def update_legend(self, ax):
if ax.get_lines():
ax.make_legend()
ax.get_legend().set_title("")
else:
if ax.get_legend():
ax.get_legend().remove()
def display_all(self):
for ax in self.get_axes():
if ax.lines:
ax.relim()
ax.autoscale()
self.update_figure()
def read_fitprop_from_browser(self):
return self.fit_browser.read_current_fitprop()
def update_browser(self, status, func_str, setup_name):
self.fit_browser.fitResultsChanged.emit(status)
self.fit_browser.changeWindowTitle.emit(status)
# update browser with output function and save setup if successful
if "success" in status.lower():
self.fit_browser.loadFunction(func_str)
self.fit_browser.save_current_setup(setup_name)
# =================
# Component Getters
# =================
def get_axes(self):
return self.figure.axes
def get_figure(self):
return self.figure
class BaseMainWindow(QMainWindow):
"""
Base for main windows of subprograms
:ivar settings: store state of application. initial value is obtained from :py:attr:`.settings_class`
:ivar files_num: maximal number of files accepted by drag and rop event
:param config_folder: path to directory in which application save state. If `settings` parameter is note
then settings object is created with passing this path to :py:attr:`.settings_class`.
If this parameter and `settings`
are None then constructor fail with :py:exc:`ValueError`.
:param title: Window default title
:param settings: object to store application state
:param signal_fun: function which need to be called when window shown.
"""
show_signal = Signal()
"""Signal emitted when window has shown. Used to hide Launcher."""
@classmethod
def get_setting_class(cls) -> Type[BaseSettings]:
"""Get constructor for :py:attr:`settings`"""
return BaseSettings
def __init__(
self,
config_folder: Union[str, Path, None] = None,
title="PartSeg",
settings: Optional[BaseSettings] = None,
load_dict: Optional[Register] = None,
signal_fun=None,
):
if settings is None:
if config_folder is None:
raise ValueError("wrong config folder")
if not os.path.exists(config_folder):
import_config()
settings: BaseSettings = self.get_setting_class()(config_folder)
errors = settings.load()
if errors:
errors_message = QMessageBox()
errors_message.setText("There are errors during start")
errors_message.setInformativeText(
"During load saved state some of data could not be load properly\n"
"The files has prepared backup copies in "
" state directory (Help > State directory)")
errors_message.setStandardButtons(QMessageBox.Ok)
text = "\n".join("File: " + x[0] + "\n" + str(x[1])
for x in errors)
errors_message.setDetailedText(text)
errors_message.exec_()
super().__init__()
if signal_fun is not None:
self.show_signal.connect(signal_fun)
self.settings = settings
self._load_dict = load_dict
self.viewer_list: List[Viewer] = []
self.files_num = 1
self.setAcceptDrops(True)
self.setWindowTitle(title)
self.title_base = title
app = QApplication.instance()
if app is not None:
app.setStyleSheet(settings.style_sheet)
self.settings.theme_changed.connect(self.change_theme)
self.channel_info = ""
self.multiple_files = None
self.settings.request_load_files.connect(self.read_drop)
self.recent_file_menu = QMenu("Open recent")
self._refresh_recent()
self.settings.connect_(FILE_HISTORY, self._refresh_recent)
self.settings.napari_settings.appearance.events.theme.connect(
self.change_theme)
self.settings.set_parent(self)
self.console = None
self.console_dock = QDockWidget("console", self)
self.console_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.BottomDockWidgetArea)
# self.console_dock.setWidget(self.console)
self.console_dock.hide()
self.addDockWidget(Qt.BottomDockWidgetArea, self.console_dock)
def _toggle_console(self):
if self.console is None:
self.console = QtConsole(self)
self.console_dock.setWidget(self.console)
self.console_dock.setVisible(not self.console_dock.isVisible())
def _refresh_recent(self):
self.recent_file_menu.clear()
for name_list, method in self.settings.get_last_files():
action = self.recent_file_menu.addAction(
f"{name_list[0]}, {method}")
action.setData((name_list, method))
action.triggered.connect(self._load_recent)
def _load_recent(self):
sender: QAction = self.sender()
data = sender.data()
try:
method: LoadBase = self._load_dict[data[1]]
dial = ExecuteFunctionDialog(
method.load, [data[0]],
exception_hook=load_data_exception_hook)
if dial.exec_():
result = dial.get_result()
self.main_menu.set_data(result)
self.settings.add_last_files(data[0], method.get_name())
self.settings.set(OPEN_DIRECTORY, os.path.dirname(data[0][0]))
self.settings.set(OPEN_FILE, data[0][0])
self.settings.set(OPEN_FILE_FILTER, data[1])
except KeyError:
self.read_drop(data[0])
def toggle_multiple_files(self):
self.settings.set("multiple_files_widget",
not self.settings.get("multiple_files_widget"))
def get_colormaps(self) -> List[Optional[colormap.Colormap]]:
channel_num = self.settings.image.channels
if not self.channel_info:
return [None for _ in range(channel_num)]
colormaps_name = [
self.settings.get_channel_colormap_name(self.channel_info, i)
for i in range(channel_num)
]
return [
self.settings.colormap_dict[name][0] for name in colormaps_name
]
def napari_viewer_show(self):
viewer = Viewer(title="Additional output",
settings=self.settings,
partseg_viewer_name=self.channel_info)
viewer.theme = self.settings.theme_name
viewer.create_initial_layers(image=True,
roi=True,
additional_layers=False,
points=True)
self.viewer_list.append(viewer)
viewer.window.qt_viewer.destroyed.connect(
lambda x: self.close_viewer(viewer))
def additional_layers_show(self, with_channels=False):
if not self.settings.additional_layers:
QMessageBox().information(
self, "No data",
"Last executed algoritm does not provide additional data")
return
viewer = Viewer(title="Additional output",
settings=self.settings,
partseg_viewer_name=self.channel_info)
viewer.theme = self.settings.theme_name
viewer.create_initial_layers(image=with_channels,
roi=False,
additional_layers=True,
points=False)
self.viewer_list.append(viewer)
viewer.window.qt_viewer.destroyed.connect(
lambda x: self.close_viewer(viewer))
def close_viewer(self, obj):
for i, el in enumerate(self.viewer_list):
if el == obj:
self.viewer_list.pop(i)
break
# @ensure_main_thread
def change_theme(self, event):
style_sheet = self.settings.style_sheet
app = QApplication.instance()
if app is not None:
app.setStyleSheet(style_sheet)
self.setStyleSheet(style_sheet)
def showEvent(self, a0: QShowEvent):
self.show_signal.emit()
def dragEnterEvent(self, event: QDragEnterEvent): # pylint: disable=R0201
if event.mimeData().hasUrls():
event.acceptProposedAction()
def read_drop(self, paths: List[str]):
"""Function to process loading files by drag and drop."""
self._read_drop(paths, self._load_dict)
def _read_drop(self, paths, load_dict):
ext_set = {os.path.splitext(x)[1].lower() for x in paths}
def exception_hook(exception):
if isinstance(exception, OSError):
QMessageBox().warning(
self, "IO Error",
"Disc operation error: " + ", ".join(exception.args),
QMessageBox.Ok)
for load_class in load_dict.values():
if load_class.partial(
) or load_class.number_of_files() != len(paths):
continue
if ext_set.issubset(load_class.get_extensions()):
dial = ExecuteFunctionDialog(load_class.load, [paths],
exception_hook=exception_hook)
if dial.exec_():
result = dial.get_result()
self.main_menu.set_data(result)
self.settings.add_last_files(paths, load_class.get_name())
return
QMessageBox.information(
self, "No method", "No methods for load files: " + ",".join(paths))
def dropEvent(self, event: QDropEvent):
"""
Support for load files by drag and drop.
At beginning it check number of files and if it greater than :py:attr:`.files_num` it refuse loading. Otherwise
it call :py:meth:`.read_drop` method and this method should be overwritten in sub classes
"""
if not all(x.isLocalFile() for x in event.mimeData().urls()):
QMessageBox().warning(
self, "Load error",
"Not all files are locally. Cannot load data.", QMessageBox.Ok)
paths = [x.toLocalFile() for x in event.mimeData().urls()]
if self.files_num != -1 and len(paths) > self.files_num:
QMessageBox.information(
self, "To many files",
"currently support only drag and drop one file")
return
self.read_drop(paths)
def show_settings_directory(self):
DirectoryDialog(
self.settings.json_folder_path,
"Path to place where PartSeg store the data between runs").exec_()
@staticmethod
def show_about_dialog():
"""Show about dialog."""
AboutDialog().exec_()
@staticmethod
def get_project_info(file_path, image):
raise NotADirectoryError()
def image_adjust_exec(self):
dial = ImageAdjustmentDialog(self.settings.image)
if dial.exec_():
algorithm = dial.result_val.algorithm
dial2 = ExecuteFunctionDialog(algorithm.transform, [], {
"image": self.settings.image,
"arguments": dial.result_val.values
})
if dial2.exec_():
result: Image = dial2.get_result()
self.settings.set_project_info(
self.get_project_info(result.file_path, result))
def closeEvent(self, event: QCloseEvent):
for el in self.viewer_list:
el.close()
del el
self.settings.napari_settings.appearance.events.theme.disconnect(
self.change_theme)
self.settings.dump()
super().closeEvent(event)
def screenshot(self, viewer: ImageView):
def _screenshot():
data = viewer.viewer_widget.screenshot()
dial = PSaveDialog(
SaveScreenshot,
settings=self.settings,
system_widget=False,
path="io.save_screenshot",
file_mode=PSaveDialog.AnyFile,
)
if not dial.exec_():
return
res = dial.get_result()
res.save_class.save(res.save_destination, data, res.parameters)
return _screenshot
def image_read(self):
folder_name, file_name = os.path.split(self.settings.image_path)
self.setWindowTitle(
f"{self.title_base}: {os.path.join(os.path.basename(folder_name), file_name)}"
)
self.statusBar().showMessage(self.settings.image_path)
def deleteLater(self) -> None:
self.settings.napari_settings.appearance.events.theme.disconnect(
self.change_theme)
super().deleteLater()
