def clear(self):
"""
desc:
Clears all settings.
"""
qsettings = QtCore.QSettings(u"cogscinl", u"opensesame")
qsettings.beginGroup(u"MainWindow")
qsettings.clear()
qsettings.endGroup()
def closeEvent(self, event):
"""
Handling saving state before application when application is
being closed.
"""
settings = QtCore.QSettings()
settings.clear()
self.settings.save(settings)
qApp.quit()
def main():
## -- log --
settings = QtCore.QSettings(osp.join(pjpath, "config/setting.ini"),
QtCore.QSettings.IniFormat)
#
# logFolder = settings.value("logFolder")
# logLevel = settings.value("logLevel")
# logDays = settings.value("logDays")
#
# if logFolder is None or len(logFolder) == 0:
# logFolder = osp.normcase(osp.join(pjpath, "log"))
# if not osp.exists(logFolder):
# os.makedirs(logFolder)
#
# if logLevel:
# logLevel = eval(logLevel)
# else:
# logLevel = logging.DEBUG
# if logDays:
# logDays = int(logDays)
# else:
# logDays = 7
# # TODO: 删除大于logDays 的 log
#
# t = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
# logging.basicConfig(
# level=logging.DEBUG,
# filename=osp.normcase(osp.join(logFolder, f"eiseg-{t}.log")),
# format="%(levelname)s - %(asctime)s - %(filename)s - %(funcName)s - %(message)s",
# )
# logger = logging.getLogger("EISeg Logger")
# handler = logging.FileHandler(osp.normcase(osp.join(logFolder, f"eiseg-{t}.log")))
#
# handler.setFormatter(
# logging.Formatter(
# "%(levelname)s - %(asctime)s - %(filename)s - %(funcName)s - %(message)s"
# )
# )
# logger.addHandler(handler)
# logger.info("test info")
#
app = QApplication(sys.argv)
lang = settings.value("language")
if lang != "中文":
trans = QtCore.QTranslator(app)
trans.load(osp.join(pjpath, f"util/translate/{lang}"))
app.installTranslator(trans)
window = APP_EISeg() # 创建对象
window.currLanguage = lang
window.showMaximized() # 全屏显示窗口
# 加载近期模型
QApplication.processEvents()
window.loadRecentModelParam()
sys.exit(app.exec())
def _createLayout(self):
"""Creates the main layout of the gui"""
from .globalSettings import SettingsToolBox
self.mainWidget = QtWidgets.QWidget()
if self._hasMenuBar:
menu_splitter = QtWidgets.QSplitter()
menu_splitter.setOrientation(QtCore.Qt.Vertical)
menu_splitter.addWidget(self.menuBar)
self.toolbox_splitter = toolbox_splitter = QtWidgets.QSplitter()
if self._hasMenuBar:
menu_splitter.addWidget(toolbox_splitter)
toolbox_splitter.setOrientation(QtCore.Qt.Horizontal)
self.settings_toolbox = SettingsToolBox(parent=toolbox_splitter)
window_splitter = QtWidgets.QSplitter(parent=toolbox_splitter)
toolbox_splitter.addWidget(window_splitter)
window_splitter.setOrientation(QtCore.Qt.Vertical)
self.window_tabber = glwindow.WindowTabber(commonContext = self._commonContext,
parent=window_splitter)
self.window_tabber._fastmode = self._flags.fastmode
window_splitter.addWidget(self.window_tabber)
if not (self._flags.noConsole and not self._flags.outputpipe):
self.output_tabber = glwindow.WindowTabber(commonContext=self._commonContext,
parent=window_splitter)
if not self._flags.noConsole:
from .console import MultiQtKernelManager, NGSJupyterWidget
self.multikernel_manager = MultiQtKernelManager()
self.console = NGSJupyterWidget(gui=self,multikernel_manager = self.multikernel_manager)
if self._hasApplication:
self.console.exit_requested.connect(self.app.quit)
self.output_tabber.addTab(self.console,"Console")
if self._flags.outputpipe:
self.outputBuffer = OutputBuffer()
self.output_tabber.addTab(self.outputBuffer, "Output")
self.output_tabber.setCurrentWidget(self.outputBuffer)
settings = QtCore.QSettings()
if settings.value("sysmon/active", "false") == "true":
from .systemmonitor import SystemMonitor
self._SysMonitor = SystemMonitor()
self._SysMonitor.setFixedHeight(30)
sysmon_splitter = QtWidgets.QSplitter(parent=window_splitter)
sysmon_splitter.setOrientation(QtCore.Qt.Vertical)
if self._flags.outputpipe or not self._flags.noConsole:
sysmon_splitter.addWidget(self.output_tabber)
sysmon_splitter.addWidget(self._SysMonitor)
sysmon_splitter.setSizes([10000,2000])
window_splitter.addWidget(sysmon_splitter)
else:
if self._flags.outputpipe or not self._flags.noConsole:
window_splitter.addWidget(self.output_tabber)
if self._hasMenuBar:
menu_splitter.setSizes([100, 10000])
window_splitter.setSizes([70000, 30000])
self.mainWidget.setLayout(ArrangeV(menu_splitter if self._hasMenuBar else toolbox_splitter))
self._addShortcuts()
def closeEvent(self, *args):
"""
Handling saving state before application when application is
being closed.
"""
settings = QtCore.QSettings()
settings.clear()
self.settings.save(settings)
if qApp is None:
sys.exit()
qApp.quit()
def save(self):
"""
desc:
Save settings to a QSettings.
"""
qsettings = QtCore.QSettings(u"cogscinl", u"opensesame")
qsettings.beginGroup(u"MainWindow")
for setting, value in self.config.items():
if setting != u"cfg_ver":
qsettings.setValue(setting, value)
qsettings.endGroup()
def _restore_settings(self):
app = QtWidgets.QApplication.instance()
settings = QtCore.QSettings(app.organizationName(),
app.applicationName())
geometry = settings.value('geometry', QtCore.QByteArray())
if not geometry.isEmpty():
self.restoreGeometry(geometry)
for key in settings.allKeys():
value = settings.value(key, None)
if key in self.settings and value is not None:
setattr(self.menu, key, value)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
settings = QtCore.QSettings()
self._sysmonCB = QtWidgets.QCheckBox("System monitor")
self._sysmonCB.setChecked(
settings.value("sysmon/active", "false") == "true")
self._sysmonCB.stateChanged.connect(self._checkSysmonRequirement)
self.setLayout(
ArrangeV(
QtWidgets.QLabel(
"Settings will get active after restarting the GUI"),
self._sysmonCB))
def __init__(self, use_settings=True):
self.widget = MainWidget()
self.model = XESModel()
self.measurement_controller = MeasurementController(widget=self.widget,
model=self.model)
self.graph_controller = GraphController(widget=self.widget,
model=self.model)
self.calibration_controller = CalibrationController(widget=self.widget,
model=self.model)
self.setup_connections()
if use_settings:
self.xes_settings = QtCore.QSettings("XES", "XES_Settings")
self.load_settings()
def addShortcut(widget, name, key, func):
"""Helper function to create shortcuts and register them in QSettings, so that
user can change them."""
settings = QtCore.QSettings()
action = QtWidgets.QAction(name)
action.triggered.connect(func)
if not settings.value("shortcuts/" + name):
settings.setValue("shortcuts/" + name, key)
action.setShortcut(QtGui.QKeySequence(settings.value("shortcuts/"+ name)))
widget.addAction(action)
if not hasattr(widget, "_qactions"):
widget._qactions = []
widget._qactions.append(action)
def onLoad(self):
QtCore.QCoreApplication.addLibraryPath(
os.path.join(os.path.dirname(QtCore.__file__), "plugins"))
QtCore.QCoreApplication.setAttribute(Qt.AA_ShareOpenGLContexts)
QtCore.QCoreApplication.setAttribute(Qt.AA_UseDesktopOpenGL)
# QtCore.QCoreApplication.setAttribute( Qt.AA_EnableHighDpiScaling )
# QtCore.QCoreApplication.setAttribute( Qt.AA_ForceRasterWidgets )
QtCore.QCoreApplication.setAttribute(
Qt.AA_DontCreateNativeWidgetSiblings)
QtCore.QCoreApplication.setAttribute(Qt.AA_CompressHighFrequencyEvents)
QtCore.QCoreApplication.setAttribute(
Qt.AA_DontCheckOpenGLContextThreadAffinity)
# QtCore.QCoreApplication.setAttribute( Qt.AA_DisableHighDpiScaling )
# QtCore.QCoreApplication.setAttribute( Qt.AA_NativeWindows )
# QtCore.QCoreApplication.setAttribute( Qt.AA_ImmediateWidgetCreation )
QtGui.QGuiApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
logging.info('loading qtApp')
try:
from PyQt4.QtCore import QT_VERSION_STR
from PyQt4.Qt import PYQT_VERSION_STR
except Exception as e:
from PyQt5.QtCore import QT_VERSION_STR
from PyQt5.QtCore import PYQT_VERSION_STR
print('QT:', QT_VERSION_STR)
print('PYQT:', PYQT_VERSION_STR)
# qtApp.setAttribute( Qt.AA_ImmediateWidgetCreation )
self.qtApp = qtApp = QtApplication([])
if self.getApp().getPlatformName() != 'Darwin':
qtApp.setWindowIcon(getGiiIcon())
logging.info('loading qtSetting')
self.qtSetting = QtCore.QSettings(
self.getProject().getConfigPath(_QT_SETTING_FILE),
QtCore.QSettings.IniFormat)
self.setupStyle()
self.setupMainWindow()
try:
from .Qt5Fix import MacClipboardFix
self.qt5MimeFix = MacClipboardFix()
except Exception as e:
pass
self.initialized = True
self.running = False
return True
def main():
app = QApplication(sys.argv)
lang = QtCore.QSettings(osp.join(pjpath, "config/setting.ini"),
QtCore.QSettings.IniFormat).value("language")
if lang != "中文":
trans = QtCore.QTranslator(app)
trans.load(osp.join(pjpath, f"util/translate/{lang}"))
app.installTranslator(trans)
window = APP_EISeg() # 创建对象
window.showMaximized() # 全屏显示窗口
# 加载近期模型
QApplication.processEvents()
window.loadRecentModelParam()
sys.exit(app.exec_())
def restore(self):
"""
desc:
Restore settings from a QSettings.
"""
qsettings = QtCore.QSettings(u"cogscinl", u"opensesame")
qsettings.beginGroup(u"MainWindow")
for setting, default in self.config.items():
try:
value = qsettings.value(setting, default)
except TypeError:
continue
value = self.type_qvariant(value, default)
self.config[setting] = value
qsettings.endGroup()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.settings = QtCore.QSettings('Sagenkoenige', 'Tasker')
self.setWindowTitle('tasker')
self.setWindowIcon(QtGui.QIcon(TASKER_ICON))
self.setGeometry(50, 50, 500, 400)
self.apply_stylesheet()
self.init_project()
self.task_manager_widget = AssemblyWidget(parent=self)
self.setCentralWidget(self.task_manager_widget)
self.make_menu_bar()
self.connect_signals()
self.refresh_ui.emit()
self.setFocus()
def __init__(self):
super().__init__()
ui_file = os.path.join(os.path.dirname(__file__), 'wizard.ui')
uic.loadUi(ui_file, self)
self.config_filepath = None
self.pdf_filepath = None
self.conf = None
self.LTE = None
self.model_elem_list = None
self.common_remote_opts = {}
self.new_report = True
self.page_name_list = [
'LTE', 'straight_centers', 'phase_adv', 'straight_length', 'test1',
'twiss_plots', 'paragraphs', 'N_KICKS', 'xy_aper_test',
'fmap_xy_test', 'fmap_px_test', 'cmap_xy_test', 'cmap_px_test',
'nonlin_chrom', 'mom_aper_test', 'tswa', 'nonlin_prod', 'rf_tau'
]
self.page_links = {}
for k in self.page_name_list:
self.page_links[k] = self.findChild(QtWidgets.QWizardPage,
f'wizardPage_{k}')
self.page_indexes = {}
for i in self.pageIds():
obj_name = self.page(i).objectName()
if obj_name.startswith('wizardPage_'):
suffix = obj_name[len('wizardPage_'):]
self.page_indexes[suffix] = i
self.setButtonText(QtWidgets.QWizard.CustomButton1, 'Jump to...')
self.showSkipButton(False)
self.customButtonClicked.connect(self.skip_to)
self.settings = QtCore.QSettings('nsls2', 'report_wizard')
self.loadSettings()
if False:
x0, y0 = 100, 300
self.setGeometry(x0, y0, 600, 400)
else:
self.setGeometry(self._settings['MainWindow']['geometry'])
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
settings = QtCore.QSettings()
shortcuts = [
name.replace("shortcuts/", "") for name in filter(
lambda name: name.startswith("shortcuts/"), settings.allKeys())
]
widgets = []
self.lineedits = {}
for shortcut in shortcuts:
lineedit = QtWidgets.QLineEdit()
lineedit.setText(settings.value("shortcuts/" + shortcut))
self.lineedits["shortcuts/" + shortcut] = lineedit
widgets.append(ArrangeH(QtWidgets.QLabel(shortcut), lineedit))
self._scrollArea = QtWidgets.QScrollArea()
self._innerWidget = QtWidgets.QWidget()
self._innerWidget.setLayout(ArrangeV(*widgets))
self._scrollArea.setWidget(self._innerWidget)
self.setLayout(ArrangeV(self._scrollArea))
def register(self, setting, default):
"""
desc:
Registers a new setting, if it doesn't already exist.
arguments:
setting: The setting name.
default: A default value, which is used if the setting doesn't
already exist.
"""
qsettings = QtCore.QSettings(u"cogscinl", u"opensesame")
qsettings.beginGroup(u"MainWindow")
if '--start-clean' in sys.argv:
self.config[setting] = default
elif setting not in self.config:
value = qsettings.value(setting, default)
value = self.type_qvariant(value, default)
self.config[setting] = value
qsettings.endGroup()
def closeEvent(self, event):
"""
Handling saving state before application when application is
being closed.
"""
settings = QtCore.QSettings()
settings.setValue("main_WindowGeometry", self.saveGeometry())
settings.setValue("mainWindowState", self.saveState())
self.settings.save(settings)
#screen_shape = QtGui.QDesktopWidget().screenGeometry()
main_window = self.window()
width = main_window.frameGeometry().width()
height = main_window.frameGeometry().height()
settings.setValue('screen_shape', (width, height))
qpos = self.pos()
pos = qpos.x(), qpos.y()
settings.setValue('pos', pos)
qApp.quit()
def _run(self,do_after_run=lambda : None, run_event_loop=True):
import sys, inspect
self.mainWidget.show()
globs = inspect.stack()[1][0].f_globals
if not self._flags.noConsole:
self.console.pushVariables(globs)
settings = QtCore.QSettings()
if self._flags.outputpipe:
self.outputBuffer.start()
if settings.value("sysmon/active", "false") == "true":
self._SysMonitor.start()
do_after_run()
if self._flags.file:
self._tryLoadFile(self._flags.file)
def onQuit():
if self._flags.outputpipe:
self.outputBuffer.onQuit()
self.app.aboutToQuit.connect(onQuit)
if run_event_loop:
sys.exit(self.app.exec_())
def test_smoke_example(qtbot, manager: qtpydocking.DockManager):
# DockManager
manager.container_overlay()
manager.dock_area_overlay()
manager.set_config_flags(manager.config_flags())
manager.find_dock_widget('')
manager.dock_widgets_map()
manager.dock_containers()
manager.floating_widgets()
manager.floating_widgets()
manager.restore_state(manager.save_state())
manager.add_perspective('test')
assert manager.perspective_names() == ['test']
settings = QtCore.QSettings()
manager.save_perspectives(settings)
manager.remove_perspectives('test')
manager.load_perspectives(settings)
manager.view_menu()
manager.open_perspective('test')
manager.set_view_menu_insertion_order(
qtpydocking.InsertionOrder.by_spelling)
# DockContainerWidget
manager.create_root_splitter()
manager.root_splitter()
manager.last_added_dock_area_widget(DockWidgetArea.left)
manager.has_top_level_dock_widget()
manager.top_level_dock_widget()
manager.top_level_dock_area()
manager.dock_widgets()
assert not manager.is_in_front_of(manager)
manager.dock_area_at(QtCore.QPoint(0, 0))
manager.dock_area(0)
assert manager.dock_area(999) is None
manager.opened_dock_areas()
manager.dock_area_count()
manager.visible_dock_area_count()
manager.dump_layout()
manager.features()
manager.floating_widget()
manager.close_other_areas(DockWidgetArea.top)
def __init__(self, parent=None):
super(AudioAnalyzerForm, self).__init__(parent)
self.settings = QtCore.QSettings(QtCore.QSettings.NativeFormat,
QtCore.QSettings.UserScope,
'BZZ Projects', 'Audio_Analyzer')
# audio data
self.audio_data = None
# audio queue and result queue
self.audio_q = queue.Queue()
self.result_q = queue.Queue()
# create audio listener and audio analyzer thr_slidereads
self.listener = Listener(self.settings, self.audio_q, self)
self.analyzer = Analyzer(self.settings,
self.audio_q, self.result_q, self)
# connect status and result update signal
self.listener.status.connect(self.updateStatus)
self.analyzer.analyzed.connect(self.updateResult)
self.timer = QtCore.QTimer(self)
self.createMainForm()
# block the operation buttons if audio input device is not available
self.timer.singleShot(200, self.checkAvailability)
def loadWindowSettings(self, settingName):
"""载入窗口设置"""
settings = QtCore.QSettings('vn.trader', settingName)
state = settings.value('state')
geometry = settings.value('geometry')
# 尚未初始化
if state is None:
return
# 老版PyQt
elif isinstance(state, QtCore.QVariant):
self.restoreState(state.toByteArray())
self.restoreGeometry(geometry.toByteArray())
# 新版PyQt
elif isinstance(state, QtCore.QByteArray):
self.restoreState(state)
self.restoreGeometry(geometry)
# 异常
else:
content = u'载入窗口配置异常，请检查'
self.mainEngine.writeLog(content)
def __init__(self, parent=None):
super().__init__(parent)
self._settings = QtCore.QSettings(QtCore.QSettings.NativeFormat,
QtCore.QSettings.UserScope,
'HF_AIO', 'MemoryUsageMonitor')
self._pid = None
self._ct = ''
self._dq = collections.deque(maxlen=self._settings.value('dq_maxlen', 120, type=int))
self._progress = QtWidgets.QProgressDialog(self)
self._progress.setCancelButton(None)
self._progress.setWindowTitle(__app_tittle__)
self._progress.setWindowModality(QtCore.Qt.WindowModal)
self._progress.setMinimumWidth(300)
self._progress.reset()
self._worker_thread = QtCore.QThread()
self._worker_thread.start()
self._log_parse_runnable = None # type: Union[None, QtCore.QObject]
self._timer = QtCore.QTimer()
self._timer.timeout.connect(self._on_timer)
self._init_ui()
self._setup_shortcuts()
def __init__(self, **kwargs):
super(MainWindow, self).__init__()
self.setWindowTitle(__appname__)
config = kwargs['config'] if 'config' in kwargs else get_config()
filename = kwargs['filename'] if 'filename' in kwargs else None
output = kwargs['output'] if 'output' in kwargs else None
output_file = kwargs['output_file'] if 'output_file' in kwargs else None
output_dir = kwargs['output_dir'] if 'output_dir' in kwargs else None
self._config = config
if filename is not None and osp.isdir(filename):
self.importDirImages(filename, load=False)
else:
self.filename = filename
if output is not None:
logger.warning(
'argument output is deprecated, use output_file instead')
if output_file is None:
output_file = output
self.output_file = output_file
self.output_dir = output_dir
self._selectedAll = False
self._noSelectionSlot = False
self.lastOpenDir = None
self.dirty = False
# widgets
self.flag_widget = QtWidgets.QListWidget()
self.flag_widget.itemChanged.connect(self.setDirty)
self.zoomWidget = ZoomWidget()
self.zoomWidget.valueChanged.connect(self.paintCanvas)
self.labelList = LabelQListWidget()
self.labelList.setParent(self)
# canvas
self.canvasInit = CanvasInit(parent=self,
epsilon=self._config['epsilon'])
self.canvas = self.canvasInit.canvas
self.labelList.canvas = self.canvas
self.setCentralWidget(self.canvasInit.canvasWidget)
# docks
self.inference = InferenceDock()
self.inference_dock = self.inference.inference_dock
self.property = PropertyDock(config=self._config)
self.property_dock = self.property.property_dock
self.defect = DefectDock(path_info=self._config['paths'])
self.defect_dock = self.defect.defect_dock
self.file = FileDock(parent=self)
self.file_dock = self.file.file_dock
self.category = CategoryDock()
self.category_dock = self.category.category_dock
features = QtWidgets.QDockWidget.DockWidgetFeatures()
for dock in [
'inference_dock', 'property_dock', 'defect_dock', 'file_dock',
'category_dock'
]:
if self._config[dock]['closable']:
features = features | QtWidgets.QDockWidget.DockWidgetClosable
if self._config[dock]['floatable']:
features = features | QtWidgets.QDockWidget.DockWidgetFloatable
if self._config[dock]['movable']:
features = features | QtWidgets.QDockWidget.DockWidgetMovable
getattr(self, dock).setFeatures(features)
if self._config[dock]['show'] is False:
getattr(self, dock).setVisible(False)
self.addDockWidget(Qt.RightDockWidgetArea, self.category_dock)
self.addDockWidget(Qt.RightDockWidgetArea, self.inference_dock)
self.addDockWidget(Qt.RightDockWidgetArea, self.property_dock)
self.addDockWidget(Qt.RightDockWidgetArea, self.defect_dock)
self.addDockWidget(Qt.RightDockWidgetArea, self.file_dock)
self.labelDialog = LabelDialog(
parent=self,
labels=self._config['labels'],
sort_labels=self._config['sort_labels'],
show_text_field=self._config['show_label_text_field'],
completion=self._config['label_completion'],
fit_to_content=self._config['fit_to_content'],
flags=self._config['label_flags'])
if config['flags']:
self.loadFlags({k: False for k in config['flags']})
if config['file_search']:
self.file.fileSearch.setText(config['file_search'])
self.file.fileSearchChanged()
# Actions, menu
self.init_action()
self.init_menu()
# Application state.
self.image = QtGui.QImage()
self.imagePath = None
self.recentFiles = []
self.maxRecent = 7
self.lineColor = None
self.fillColor = None
self.otherData = None
self.zoom_level = 100
self.fit_window = False
# Restore application settings.
self.settings = QtCore.QSettings('ImageDefectAnalytics',
'ImageDefectAnalytics')
self.recentFiles = self.settings.value('recentFiles', []) or []
self.resize(self.settings.value('window/size', QtCore.QSize(600, 500)))
self.move(self.settings.value('window/position', QtCore.QPoint(0, 0)))
self.restoreState(
self.settings.value('window/state', QtCore.QByteArray()))
self.populateModeActions()
self.updateFileMenu()
if self.filename is not None:
self.queueEvent(functools.partial(self.loadFile, self.filename))
self.statusBar().showMessage('%s started.' % __appname__)
self.statusBar().show()
def on_activate(self):
""" Definition, configuration and initialisation of the ODMR GUI.
This init connects all the graphic modules, which were created in the
*.ui file and configures the event handling between the modules.
"""
self._odmr_logic = self.odmrlogic1()
# Use the inherited class 'Ui_ODMRGuiUI' to create now the GUI element:
self._mw = ODMRMainWindow()
self._sd = ODMRSettingDialog()
# Create a QSettings object for the mainwindow and store the actual GUI layout
self.mwsettings = QtCore.QSettings("QUDI", "ODMR")
self.mwsettings.setValue("geometry", self._mw.saveGeometry())
self.mwsettings.setValue("windowState", self._mw.saveState())
# Get hardware constraints to set limits for input widgets
constraints = self._odmr_logic.get_hw_constraints()
# Adjust range of scientific spinboxes above what is possible in Qt Designer
self._mw.cw_frequency_DoubleSpinBox.setMaximum(
constraints.max_frequency)
self._mw.cw_frequency_DoubleSpinBox.setMinimum(
constraints.min_frequency)
self._mw.start_freq_DoubleSpinBox.setMaximum(constraints.max_frequency)
self._mw.start_freq_DoubleSpinBox.setMinimum(constraints.min_frequency)
self._mw.step_freq_DoubleSpinBox.setMaximum(100e9)
self._mw.stop_freq_DoubleSpinBox.setMaximum(constraints.max_frequency)
self._mw.stop_freq_DoubleSpinBox.setMinimum(constraints.min_frequency)
self._mw.cw_power_DoubleSpinBox.setMaximum(constraints.max_power)
self._mw.cw_power_DoubleSpinBox.setMinimum(constraints.min_power)
self._mw.sweep_power_DoubleSpinBox.setMaximum(constraints.max_power)
self._mw.sweep_power_DoubleSpinBox.setMinimum(constraints.min_power)
# Add save file tag input box
self._mw.save_tag_LineEdit = QtWidgets.QLineEdit(self._mw)
self._mw.save_tag_LineEdit.setMaximumWidth(500)
self._mw.save_tag_LineEdit.setMinimumWidth(200)
self._mw.save_tag_LineEdit.setToolTip('Enter a nametag which will be\n'
'added to the filename.')
self._mw.save_ToolBar.addWidget(self._mw.save_tag_LineEdit)
# add a clear button to clear the ODMR plots:
self._mw.clear_odmr_PushButton = QtWidgets.QPushButton(self._mw)
self._mw.clear_odmr_PushButton.setText('Clear ODMR')
self._mw.clear_odmr_PushButton.setToolTip('Clear the data of the\n'
'current ODMR measurements.')
self._mw.clear_odmr_PushButton.setEnabled(False)
self._mw.toolBar.addWidget(self._mw.clear_odmr_PushButton)
# Set up and connect channel combobox
self.display_channel = 0
odmr_channels = self._odmr_logic.get_odmr_channels()
for n, ch in enumerate(odmr_channels):
self._mw.odmr_channel_ComboBox.addItem(str(ch), n)
self._mw.odmr_channel_ComboBox.activated.connect(self.update_channel)
# Get the image from the logic
self.odmr_matrix_image = pg.ImageItem(
self._odmr_logic.odmr_plot_xy[:, self.display_channel],
axisOrder='row-major')
self.odmr_matrix_image.setRect(
QtCore.QRectF(self._odmr_logic.mw_start, 0,
self._odmr_logic.mw_stop - self._odmr_logic.mw_start,
self._odmr_logic.number_of_lines))
self.odmr_image = pg.PlotDataItem(
self._odmr_logic.odmr_plot_x,
self._odmr_logic.odmr_plot_y[self.display_channel],
pen=pg.mkPen(palette.c1, style=QtCore.Qt.DotLine),
symbol='o',
symbolPen=palette.c1,
symbolBrush=palette.c1,
symbolSize=7)
self.odmr_fit_image = pg.PlotDataItem(self._odmr_logic.odmr_fit_x,
self._odmr_logic.odmr_fit_y,
pen=pg.mkPen(palette.c2))
# Add the display item to the xy and xz ViewWidget, which was defined in the UI file.
self._mw.odmr_PlotWidget.addItem(self.odmr_image)
self._mw.odmr_PlotWidget.setLabel(axis='left',
text='Counts',
units='Counts/s')
self._mw.odmr_PlotWidget.setLabel(axis='bottom',
text='Frequency',
units='Hz')
self._mw.odmr_PlotWidget.showGrid(x=True, y=True, alpha=0.8)
self._mw.odmr_matrix_PlotWidget.addItem(self.odmr_matrix_image)
self._mw.odmr_matrix_PlotWidget.setLabel(axis='left',
text='Matrix Lines',
units='#')
self._mw.odmr_matrix_PlotWidget.setLabel(axis='bottom',
text='Frequency',
units='Hz')
# Get the colorscales at set LUT
my_colors = ColorScaleInferno()
self.odmr_matrix_image.setLookupTable(my_colors.lut)
########################################################################
# Configuration of the Colorbar #
########################################################################
self.odmr_cb = ColorBar(my_colors.cmap_normed, 100, 0, 100000)
# adding colorbar to ViewWidget
self._mw.odmr_cb_PlotWidget.addItem(self.odmr_cb)
self._mw.odmr_cb_PlotWidget.hideAxis('bottom')
self._mw.odmr_cb_PlotWidget.hideAxis('left')
self._mw.odmr_cb_PlotWidget.setLabel('right',
'Fluorescence',
units='counts/s')
########################################################################
# Configuration of the various display Widgets #
########################################################################
# Take the default values from logic:
self._mw.cw_frequency_DoubleSpinBox.setValue(
self._odmr_logic.cw_mw_frequency)
self._mw.start_freq_DoubleSpinBox.setValue(self._odmr_logic.mw_start)
self._mw.stop_freq_DoubleSpinBox.setValue(self._odmr_logic.mw_stop)
self._mw.step_freq_DoubleSpinBox.setValue(self._odmr_logic.mw_step)
self._mw.cw_power_DoubleSpinBox.setValue(self._odmr_logic.cw_mw_power)
self._mw.sweep_power_DoubleSpinBox.setValue(
self._odmr_logic.sweep_mw_power)
self._mw.runtime_DoubleSpinBox.setValue(self._odmr_logic.run_time)
self._mw.elapsed_time_DisplayWidget.display(
int(np.rint(self._odmr_logic.elapsed_time)))
self._mw.elapsed_sweeps_DisplayWidget.display(
self._odmr_logic.elapsed_sweeps)
self._mw.average_level_SpinBox.setValue(
self._odmr_logic.lines_to_average)
self._sd.matrix_lines_SpinBox.setValue(
self._odmr_logic.number_of_lines)
self._sd.clock_frequency_DoubleSpinBox.setValue(
self._odmr_logic.clock_frequency)
self._sd.oversampling_SpinBox.setValue(self._odmr_logic.oversampling)
self._sd.lock_in_CheckBox.setChecked(self._odmr_logic.lock_in)
# fit settings
self._fsd = FitSettingsDialog(self._odmr_logic.fc)
self._fsd.sigFitsUpdated.connect(
self._mw.fit_methods_ComboBox.setFitFunctions)
self._fsd.applySettings()
self._mw.action_FitSettings.triggered.connect(self._fsd.show)
########################################################################
# Connect signals #
########################################################################
# Internal user input changed signals
self._mw.cw_frequency_DoubleSpinBox.editingFinished.connect(
self.change_cw_params)
self._mw.start_freq_DoubleSpinBox.editingFinished.connect(
self.change_sweep_params)
self._mw.step_freq_DoubleSpinBox.editingFinished.connect(
self.change_sweep_params)
self._mw.stop_freq_DoubleSpinBox.editingFinished.connect(
self.change_sweep_params)
self._mw.sweep_power_DoubleSpinBox.editingFinished.connect(
self.change_sweep_params)
self._mw.cw_power_DoubleSpinBox.editingFinished.connect(
self.change_cw_params)
self._mw.runtime_DoubleSpinBox.editingFinished.connect(
self.change_runtime)
self._mw.odmr_cb_max_DoubleSpinBox.valueChanged.connect(
self.colorscale_changed)
self._mw.odmr_cb_min_DoubleSpinBox.valueChanged.connect(
self.colorscale_changed)
self._mw.odmr_cb_high_percentile_DoubleSpinBox.valueChanged.connect(
self.colorscale_changed)
self._mw.odmr_cb_low_percentile_DoubleSpinBox.valueChanged.connect(
self.colorscale_changed)
self._mw.average_level_SpinBox.valueChanged.connect(
self.average_level_changed)
# Internal trigger signals
self._mw.odmr_cb_manual_RadioButton.clicked.connect(
self.colorscale_changed)
self._mw.odmr_cb_centiles_RadioButton.clicked.connect(
self.colorscale_changed)
self._mw.clear_odmr_PushButton.clicked.connect(self.clear_odmr_data)
self._mw.action_run_stop.triggered.connect(self.run_stop_odmr)
self._mw.action_resume_odmr.triggered.connect(self.resume_odmr)
self._mw.action_toggle_cw.triggered.connect(self.toggle_cw_mode)
self._mw.action_Save.triggered.connect(self.save_data)
self._mw.action_RestoreDefault.triggered.connect(
self.restore_defaultview)
self._mw.do_fit_PushButton.clicked.connect(self.do_fit)
# Control/values-changed signals to logic
self.sigCwMwOn.connect(self._odmr_logic.mw_cw_on,
QtCore.Qt.QueuedConnection)
self.sigMwOff.connect(self._odmr_logic.mw_off,
QtCore.Qt.QueuedConnection)
self.sigClearData.connect(self._odmr_logic.clear_odmr_data,
QtCore.Qt.QueuedConnection)
self.sigStartOdmrScan.connect(self._odmr_logic.start_odmr_scan,
QtCore.Qt.QueuedConnection)
self.sigStopOdmrScan.connect(self._odmr_logic.stop_odmr_scan,
QtCore.Qt.QueuedConnection)
self.sigContinueOdmrScan.connect(self._odmr_logic.continue_odmr_scan,
QtCore.Qt.QueuedConnection)
self.sigDoFit.connect(self._odmr_logic.do_fit,
QtCore.Qt.QueuedConnection)
self.sigMwCwParamsChanged.connect(self._odmr_logic.set_cw_parameters,
QtCore.Qt.QueuedConnection)
self.sigMwSweepParamsChanged.connect(
self._odmr_logic.set_sweep_parameters, QtCore.Qt.QueuedConnection)
self.sigRuntimeChanged.connect(self._odmr_logic.set_runtime,
QtCore.Qt.QueuedConnection)
self.sigNumberOfLinesChanged.connect(
self._odmr_logic.set_matrix_line_number,
QtCore.Qt.QueuedConnection)
self.sigClockFreqChanged.connect(self._odmr_logic.set_clock_frequency,
QtCore.Qt.QueuedConnection)
self.sigOversamplingChanged.connect(self._odmr_logic.set_oversampling,
QtCore.Qt.QueuedConnection)
self.sigLockInChanged.connect(self._odmr_logic.set_lock_in,
QtCore.Qt.QueuedConnection)
self.sigSaveMeasurement.connect(self._odmr_logic.save_odmr_data,
QtCore.Qt.QueuedConnection)
self.sigAverageLinesChanged.connect(
self._odmr_logic.set_average_length, QtCore.Qt.QueuedConnection)
# Update signals coming from logic:
self._odmr_logic.sigParameterUpdated.connect(
self.update_parameter, QtCore.Qt.QueuedConnection)
self._odmr_logic.sigOutputStateUpdated.connect(
self.update_status, QtCore.Qt.QueuedConnection)
self._odmr_logic.sigOdmrPlotsUpdated.connect(
self.update_plots, QtCore.Qt.QueuedConnection)
self._odmr_logic.sigOdmrFitUpdated.connect(self.update_fit,
QtCore.Qt.QueuedConnection)
self._odmr_logic.sigOdmrElapsedTimeUpdated.connect(
self.update_elapsedtime, QtCore.Qt.QueuedConnection)
# connect settings signals
self._mw.action_Settings.triggered.connect(self._menu_settings)
self._sd.accepted.connect(self.update_settings)
self._sd.rejected.connect(self.reject_settings)
self._sd.buttonBox.button(
QtWidgets.QDialogButtonBox.Apply).clicked.connect(
self.update_settings)
self.reject_settings()
# Show the Main ODMR GUI:
self.show()
def __init__(self, config=None, filename=None, output=None):
# see labelme/config/default_config.yaml for valid configuration
if config is None:
config = get_config()
self._config = config
super(MainWindow, self).__init__()
self.setWindowTitle(__appname__)
# Whether we need to save or not.
self.dirty = False
self._noSelectionSlot = False
# Main widgets and related state.
self.labelDialog = LabelDialog(
parent=self,
labels=self._config['labels'],
sort_labels=self._config['sort_labels'],
show_text_field=self._config['show_label_text_field'],
)
self.labelList = LabelQListWidget()
self.lastOpenDir = None
self.labelList.itemActivated.connect(self.labelSelectionChanged)
self.labelList.itemSelectionChanged.connect(self.labelSelectionChanged)
self.labelList.itemDoubleClicked.connect(self.editLabel)
# Connect to itemChanged to detect checkbox changes.
self.labelList.itemChanged.connect(self.labelItemChanged)
self.labelList.setDragDropMode(
QtWidgets.QAbstractItemView.InternalMove)
self.labelList.setParent(self)
listLayout = QtWidgets.QVBoxLayout()
listLayout.setContentsMargins(0, 0, 0, 0)
self.editButton = QtWidgets.QToolButton()
self.editButton.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
listLayout.addWidget(self.editButton) # 0, Qt.AlignCenter)
listLayout.addWidget(self.labelList)
self.labelListContainer = QtWidgets.QWidget()
self.labelListContainer.setLayout(listLayout)
self.uniqLabelList = EscapableQListWidget()
self.uniqLabelList.setToolTip(
"Select label to start annotating for it. "
"Press 'Esc' to deselect.")
if self._config['labels']:
self.uniqLabelList.addItems(self._config['labels'])
self.uniqLabelList.sortItems()
self.labelsdock = QtWidgets.QDockWidget(u'Label List', self)
self.labelsdock.setObjectName(u'Label List')
self.labelsdock.setWidget(self.uniqLabelList)
self.dock = QtWidgets.QDockWidget('Polygon Labels', self)
self.dock.setObjectName('Labels')
self.dock.setWidget(self.labelListContainer)
self.fileListWidget = QtWidgets.QListWidget()
self.fileListWidget.itemSelectionChanged.connect(
self.fileSelectionChanged)
filelistLayout = QtWidgets.QVBoxLayout()
filelistLayout.setContentsMargins(0, 0, 0, 0)
filelistLayout.addWidget(self.fileListWidget)
fileListContainer = QtWidgets.QWidget()
fileListContainer.setLayout(filelistLayout)
self.filedock = QtWidgets.QDockWidget(u'File List', self)
self.filedock.setObjectName(u'Files')
self.filedock.setWidget(fileListContainer)
self.zoomWidget = ZoomWidget()
self.colorDialog = ColorDialog(parent=self)
self.canvas = self.labelList.canvas = Canvas()
self.canvas.zoomRequest.connect(self.zoomRequest)
scrollArea = QtWidgets.QScrollArea()
scrollArea.setWidget(self.canvas)
scrollArea.setWidgetResizable(True)
self.scrollBars = {
Qt.Vertical: scrollArea.verticalScrollBar(),
Qt.Horizontal: scrollArea.horizontalScrollBar(),
}
self.canvas.scrollRequest.connect(self.scrollRequest)
self.canvas.newShape.connect(self.newShape)
self.canvas.shapeMoved.connect(self.setDirty)
self.canvas.selectionChanged.connect(self.shapeSelectionChanged)
self.canvas.drawingPolygon.connect(self.toggleDrawingSensitive)
self.setCentralWidget(scrollArea)
self.addDockWidget(Qt.RightDockWidgetArea, self.labelsdock)
self.addDockWidget(Qt.RightDockWidgetArea, self.dock)
self.addDockWidget(Qt.RightDockWidgetArea, self.filedock)
self.filedock.setFeatures(QtWidgets.QDockWidget.DockWidgetFloatable)
self.dockFeatures = (QtWidgets.QDockWidget.DockWidgetClosable
| QtWidgets.QDockWidget.DockWidgetFloatable)
self.dock.setFeatures(self.dock.features() ^ self.dockFeatures)
# Actions
action = functools.partial(newAction, self)
shortcuts = self._config['shortcuts']
quit = action('&Quit', self.close, shortcuts['quit'], 'quit',
'Quit application')
open_ = action('&Open', self.openFile, shortcuts['open'], 'open',
'Open image or label file')
opendir = action('&Open Dir', self.openDirDialog,
shortcuts['open_dir'], 'open', u'Open Dir')
openNextImg = action('&Next Image', self.openNextImg,
shortcuts['open_next'], 'next', u'Open Next')
openPrevImg = action('&Prev Image', self.openPrevImg,
shortcuts['open_prev'], 'prev', u'Open Prev')
save = action('&Save',
self.saveFile,
shortcuts['save'],
'save',
'Save labels to file',
enabled=False)
saveAs = action('&Save As',
self.saveFileAs,
shortcuts['save_as'],
'save-as',
'Save labels to a different file',
enabled=False)
close = action('&Close', self.closeFile, shortcuts['close'], 'close',
'Close current file')
color1 = action('Polygon &Line Color', self.chooseColor1,
shortcuts['edit_line_color'], 'color_line',
'Choose polygon line color')
color2 = action('Polygon &Fill Color', self.chooseColor2,
shortcuts['edit_fill_color'], 'color',
'Choose polygon fill color')
createMode = action('Create\nPolygo&ns',
self.setCreateMode,
shortcuts['create_polygon'],
'objects',
'Start drawing polygons',
enabled=True)
editMode = action('&Edit\nPolygons',
self.setEditMode,
shortcuts['edit_polygon'],
'edit',
'Move and edit polygons',
enabled=True)
delete = action('Delete\nPolygon',
self.deleteSelectedShape,
shortcuts['delete_polygon'],
'cancel',
'Delete',
enabled=False)
copy = action('&Duplicate\nPolygon',
self.copySelectedShape,
shortcuts['duplicate_polygon'],
'copy',
'Create a duplicate of the selected polygon',
enabled=False)
undoLastPoint = action('Undo last point',
self.canvas.undoLastPoint,
shortcuts['undo_last_point'],
'undo',
'Undo last drawn point',
enabled=False)
undo = action('Undo',
self.undoShapeEdit,
shortcuts['undo'],
'undo',
'Undo last add and edit of shape',
enabled=False)
hideAll = action('&Hide\nPolygons',
functools.partial(self.togglePolygons, False),
icon='eye',
tip='Hide all polygons',
enabled=False)
showAll = action('&Show\nPolygons',
functools.partial(self.togglePolygons, True),
icon='eye',
tip='Show all polygons',
enabled=False)
help = action('&Tutorial',
self.tutorial,
icon='help',
tip='Show tutorial page')
zoom = QtWidgets.QWidgetAction(self)
zoom.setDefaultWidget(self.zoomWidget)
self.zoomWidget.setWhatsThis(
"Zoom in or out of the image. Also accessible with"
" %s and %s from the canvas." %
(fmtShortcut('%s,%s' %
(shortcuts['zoom_in'], shortcuts['zoom_out'])),
fmtShortcut("Ctrl+Wheel")))
self.zoomWidget.setEnabled(False)
zoomIn = action('Zoom &In',
functools.partial(self.addZoom, 10),
shortcuts['zoom_in'],
'zoom-in',
'Increase zoom level',
enabled=False)
zoomOut = action('&Zoom Out',
functools.partial(self.addZoom, -10),
shortcuts['zoom_out'],
'zoom-out',
'Decrease zoom level',
enabled=False)
zoomOrg = action('&Original size',
functools.partial(self.setZoom, 100),
shortcuts['zoom_to_original'],
'zoom',
'Zoom to original size',
enabled=False)
fitWindow = action('&Fit Window',
self.setFitWindow,
shortcuts['fit_window'],
'fit-window',
'Zoom follows window size',
checkable=True,
enabled=False)
fitWidth = action('Fit &Width',
self.setFitWidth,
shortcuts['fit_width'],
'fit-width',
'Zoom follows window width',
checkable=True,
enabled=False)
# Group zoom controls into a list for easier toggling.
zoomActions = (self.zoomWidget, zoomIn, zoomOut, zoomOrg, fitWindow,
fitWidth)
self.zoomMode = self.MANUAL_ZOOM
self.scalers = {
self.FIT_WINDOW:
self.scaleFitWindow,
self.FIT_WIDTH:
self.scaleFitWidth,
# Set to one to scale to 100% when loading files.
self.MANUAL_ZOOM:
lambda: 1,
}
edit = action('&Edit Label',
self.editLabel,
shortcuts['edit_label'],
'edit',
'Modify the label of the selected polygon',
enabled=False)
self.editButton.setDefaultAction(edit)
shapeLineColor = action(
'Shape &Line Color',
self.chshapeLineColor,
icon='color-line',
tip='Change the line color for this specific shape',
enabled=False)
shapeFillColor = action(
'Shape &Fill Color',
self.chshapeFillColor,
icon='color',
tip='Change the fill color for this specific shape',
enabled=False)
labels = self.dock.toggleViewAction()
labels.setText('Show/Hide Label Panel')
# Lavel list context menu.
labelMenu = QtWidgets.QMenu()
addActions(labelMenu, (edit, delete))
self.labelList.setContextMenuPolicy(Qt.CustomContextMenu)
self.labelList.customContextMenuRequested.connect(
self.popLabelListMenu)
# Store actions for further handling.
self.actions = struct(
save=save,
saveAs=saveAs,
open=open_,
close=close,
lineColor=color1,
fillColor=color2,
delete=delete,
edit=edit,
copy=copy,
undoLastPoint=undoLastPoint,
undo=undo,
createMode=createMode,
editMode=editMode,
shapeLineColor=shapeLineColor,
shapeFillColor=shapeFillColor,
zoom=zoom,
zoomIn=zoomIn,
zoomOut=zoomOut,
zoomOrg=zoomOrg,
fitWindow=fitWindow,
fitWidth=fitWidth,
zoomActions=zoomActions,
fileMenuActions=(open_, opendir, save, saveAs, close, quit),
tool=(),
editMenu=(edit, copy, delete, None, undo, undoLastPoint, None,
color1, color2),
menu=(
createMode,
editMode,
edit,
copy,
delete,
shapeLineColor,
shapeFillColor,
undo,
undoLastPoint,
),
onLoadActive=(close, createMode, editMode),
onShapesPresent=(saveAs, hideAll, showAll),
)
self.menus = struct(
file=self.menu('&File'),
edit=self.menu('&Edit'),
view=self.menu('&View'),
help=self.menu('&Help'),
recentFiles=QtWidgets.QMenu('Open &Recent'),
labelList=labelMenu,
)
addActions(self.menus.file, (open_, opendir, self.menus.recentFiles,
save, saveAs, close, None, quit))
addActions(self.menus.help, (help, ))
addActions(self.menus.view,
(labels, None, hideAll, showAll, None, zoomIn, zoomOut,
zoomOrg, None, fitWindow, fitWidth))
self.menus.file.aboutToShow.connect(self.updateFileMenu)
# Custom context menu for the canvas widget:
addActions(self.canvas.menus[0], self.actions.menu)
addActions(self.canvas.menus[1],
(action('&Copy here', self.copyShape),
action('&Move here', self.moveShape)))
self.tools = self.toolbar('Tools')
self.actions.tool = (open_, opendir, openNextImg, openPrevImg, save,
None, createMode, copy, delete, editMode, undo,
None, zoomIn, zoom, zoomOut, fitWindow, fitWidth)
self.statusBar().showMessage('%s started.' % __appname__)
self.statusBar().show()
# Application state.
self.image = QtGui.QImage()
self.imagePath = None
if self._config['auto_save'] and output is not None:
warnings.warn('If `auto_save` argument is True, `output` argument '
'is ignored and output filename is automatically '
'set as IMAGE_BASENAME.json.')
self.labeling_once = output is not None
self.output = output
self.recentFiles = []
self.maxRecent = 7
self.lineColor = None
self.fillColor = None
self.otherData = None
self.zoom_level = 100
self.fit_window = False
if filename is not None and os.path.isdir(filename):
self.importDirImages(filename, load=False)
else:
self.filename = filename
# XXX: Could be completely declarative.
# Restore application settings.
self.settings = QtCore.QSettings('labelme', 'labelme')
# FIXME: QSettings.value can return None on PyQt4
self.recentFiles = self.settings.value('recentFiles', []) or []
size = self.settings.value('window/size', QtCore.QSize(600, 500))
position = self.settings.value('window/position', QtCore.QPoint(0, 0))
self.resize(size)
self.move(position)
# or simply:
# self.restoreGeometry(settings['window/geometry']
self.restoreState(
self.settings.value('window/state', QtCore.QByteArray()))
self.lineColor = QtGui.QColor(
self.settings.value('line/color', Shape.line_color))
self.fillColor = QtGui.QColor(
self.settings.value('fill/color', Shape.fill_color))
Shape.line_color = self.lineColor
Shape.fill_color = self.fillColor
# Populate the File menu dynamically.
self.updateFileMenu()
# Since loading the file may take some time,
# make sure it runs in the background.
if self.filename is not None:
self.queueEvent(functools.partial(self.loadFile, self.filename))
# Callbacks:
self.zoomWidget.valueChanged.connect(self.paintCanvas)
self.populateModeActions()
def __init__(
self,
file_or_folder,
output_file=None,
output_dir=None,
):
super(MainWindow, self).__init__()
self.action_storage = utils.ActionStorage(self)
# Whether we need to save or not.
self.dirty = False
self.label_file = None
if output_file:
if Config.get('auto_save'):
logger.warn(
'If `auto_save` argument is True, `output_file` argument '
'is ignored and output filename is automatically '
'set as IMAGE_BASENAME.json.')
self.label_file = output_file
# Ignore signal flags
self._noSelectionSlot = False
# Last open directory
self.lastOpenDir = None
self._uri = None
self.output_dir = output_dir
self.zoomMode = self.FIT_WINDOW
self.scalers = {
self.FIT_WINDOW:
self.scaleFitWindow,
self.FIT_WIDTH:
self.scaleFitWidth,
# Set to one to scale to 100% when loading files.
self.MANUAL_ZOOM:
lambda: 1,
}
# Application state.
# Restore application settings.
# FIXME: QSettings.value can return None on PyQt4
self.settings = QtCore.QSettings('labelme_client', 'labelme_client')
self.recentFiles = self.settings.value('recentFiles', []) or []
self.lineColor = self.settings.value('line/color', None)
self.fillColor = self.settings.value('fill/color', None)
geometry = self.settings.value('window/geometry')
if geometry:
self.restoreGeometry(geometry)
self.restoreState(
self.settings.value('window/state', QtCore.QByteArray()))
self.ui = UIMainWindow()
self.ui.setup_ui(self)
self.statusBar().showMessage('%s started.' % __appname__)
self.statusBar().show()
if Config.get('file_search'):
self.fileSearch.setText(Config.get('file_search'))
# Populate actions in menus
self.populate_actions()
# Populate the File menu dynamically.
self.updateFileMenu()
# Set and load URI
self.uri = URI.from_file_or_folder(file_or_folder, output_dir) \
if file_or_folder else None
def initUI(self):
def selection_changed():
# Retrieve selected items
# selecteditems = self.tracklist.selectedItems()
selectedindexes = self.tracklist.selectedIndexes()
# Adding the selected items to the processing list
self.gpxselectedlist[:] = []
self.gpxselectednamelist[:] = []
self.selectedpalette[:] = []
for i in selectedindexes:
# print str(i.text())
self.gpxselectedlist.append(self.gpxlist[i.row()])
self.gpxselectednamelist.append(self.gpxnamelist[i.row()])
self.selectedpalette.append(self.palette[i.row()])
def ClearStats():
"""
# Some other code that could be used in the future
index = self.treemodel.indexFromItem(parent1)
self.tree.expand(index)
selmod = self.tree.selectionModel()
index2 = self.treemodel.indexFromItem(child2)
selmod.select(index2, QtCore.QItemSelectionModel.Select|QtCore.QItemSelectionModel.Rows)
root = self.treemodel.invisibleRootItem()
(item.parent() or root).removeChild(item)
"""
# Returns a list of indexes. In our case, for each row there are 2 indexes, cos there are 2 columns.
for index in self.tree.selectedIndexes():
# Consider only the first columns
if index.column() == 0:
# Need to check if it's a top item (i.e. track), otherwise if a subitem (i.e. distance or time) is selected, the result might be buggy
parent = index.parent()
parent_item = self.treemodel.itemFromIndex(parent)
if parent_item is None:
self.treemodel.removeRow(index.row())
# Application Settings
QtCore.QCoreApplication.setOrganizationName("Ste")
QtCore.QCoreApplication.setOrganizationDomain(
"https://github.com/stesalati/sport/")
QtCore.QCoreApplication.setApplicationName("TrackAnalyser")
# Config settings
self.settings = QtCore.QSettings(self)
# Proxy settings
try:
self.use_proxy = self.settings.value('use_proxy', bool)
self.proxy_config = self.settings.value('proxy_config', str)
except:
self.use_proxy = bombo.USE_PROXY
self.proxy_config = bombo.PROXY_DATA
# Actions
openfile = QAction(QtGui.QIcon("icons/openfile.png"), "Open .gpx",
self)
openfile.setShortcut("Ctrl+O")
openfile.setStatusTip("Open file")
openfile.triggered.connect(self.selectFileToOpen)
go = QAction(QtGui.QIcon("icons/go.png"), "Go!", self)
go.setShortcut("Ctrl+R")
go.setStatusTip("Run analysis")
go.triggered.connect(self.Go)
clearstats = QAction(QtGui.QIcon("icons/clear.png"), "Clear stats",
self)
clearstats.setShortcut("Ctrl+C")
clearstats.setStatusTip("Clear stats")
clearstats.triggered.connect(ClearStats)
sep1 = QAction(self)
sep1.setSeparator(True)
showpoint = QAction(QtGui.QIcon("icons/point.png"), "Show point", self)
showpoint.setShortcut("Ctrl+P")
showpoint.setStatusTip("Show point")
showpoint.triggered.connect(self.PlotSpecificAreaDialog)
sep2 = QAction(self)
sep2.setSeparator(True)
quitapp = QAction(QtGui.QIcon("icons/quit.png"), "Quit", self)
quitapp.setShortcut("Ctrl+Q")
quitapp.setStatusTip("Quit application")
quitapp.triggered.connect(qApp.quit)
configs = QAction(QtGui.QIcon("icons/configs.png"), "Configs", self)
configs.setStatusTip("Configs")
configs.triggered.connect(self.ProxyDialog)
# Menubar
mainMenu = self.menuBar()
configMenu = mainMenu.addMenu('&Config')
configMenu.addAction(configs)
# Toolbar
toolbar = self.addToolBar('My tools')
toolbar.addAction(openfile)
toolbar.addAction(go)
toolbar.addAction(clearstats)
toolbar.addAction(sep1)
toolbar.addAction(showpoint)
toolbar.addAction(sep2)
toolbar.addAction(quitapp)
toolbar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
toolbar.setIconSize(QtCore.QSize(30, 30))
# Status bar
self.statusBar().show()
# Main widget (everything that's not toolbar, statusbar or menubar must be in this widget)
self.scatola = QWidget()
# Main horizontal impagination
hBox = QHBoxLayout()
hBox.setSpacing(5)
# Vertical left column
vBox_left = QVBoxLayout()
vBox_left.setSpacing(5)
# 1st vertical box, a list
self.tracklist = QListWidget()
vBox_left.addWidget(self.tracklist)
self.tracklist.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.tracklist.itemSelectionChanged.connect(selection_changed)
self.tracklist.setMaximumHeight(120)
# 2nd vertical box, containing several horizontal boxes, one for each setting
vBox2 = QVBoxLayout()
vBox2.setSpacing(5)
# Just the group label
labelSettings = QLabel('Settings')
vBox2.addWidget(labelSettings)
# Use/don't use corrected altitude
self.checkUseSRTM = QCheckBox(
"Use SRTM corrected elevation (needs Internet)")
self.checkUseSRTM.setChecked(False)
vBox2.addWidget(self.checkUseSRTM)
# Choose processing method + use/don't use acceleration
hBoxProcessingMethod = QHBoxLayout()
labelProcessingMethod = QLabel('Processing method')
hBoxProcessingMethod.addWidget(labelProcessingMethod)
self.comboBoxProcessingMethod = QComboBox()
self.comboBoxProcessingMethod.addItem("Just use available data")
self.comboBoxProcessingMethod.addItem(
"Fill all gaps at T=1s (resample)")
self.comboBoxProcessingMethod.addItem("Fill only smaller gaps at T=1s")
hBoxProcessingMethod.addWidget(self.comboBoxProcessingMethod)
self.checkUseAcceleration = QCheckBox("Use acceleration")
self.checkUseAcceleration.setChecked(False)
hBoxProcessingMethod.addWidget(self.checkUseAcceleration)
vBox2.addLayout(hBoxProcessingMethod)
# Use/don't use variance smooth
self.checkExtraSmooth = QCheckBox("Extra smooth")
self.checkExtraSmooth.setChecked(False)
vBox2.addWidget(self.checkExtraSmooth)
# 2D interactive map settings
hBox2DMap = QHBoxLayout()
self.checkUseRDP = QCheckBox("Use RDP to reduce points")
self.checkUseRDP.setChecked(False)
hBox2DMap.addWidget(self.checkUseRDP)
self.check2DMapInExternalBrowser = QCheckBox(
"Show in external browser")
self.check2DMapInExternalBrowser.setChecked(False)
hBox2DMap.addWidget(self.check2DMapInExternalBrowser)
vBox2.addLayout(hBox2DMap)
# Settings for the 3D map
line3DViewSettings = QFrame()
#line3DViewSettings.setGeometry(QtCore.QRect(320, 150, 118, 3))
line3DViewSettings.setFrameShape(QFrame.HLine)
line3DViewSettings.setFrameShadow(QFrame.Sunken)
vBox2.addWidget(line3DViewSettings)
label3DViewSettings = QLabel('3D view settings')
vBox2.addWidget(label3DViewSettings)
hBox3DMapSelection = QHBoxLayout()
self.check3DMapSelection = QCheckBox(
"Select elevation tiles automatically, otherwise")
self.check3DMapSelection.setChecked(True)
hBox3DMapSelection.addWidget(self.check3DMapSelection)
self.text3DMapName = QLineEdit()
self.text3DMapName.setText("Iceland.tif")
hBox3DMapSelection.addWidget(self.text3DMapName)
vBox2.addLayout(hBox3DMapSelection)
hBox3D = QHBoxLayout()
label3DMargin = QLabel('Margin')
hBox3D.addWidget(label3DMargin)
self.spinbox3DMargin = QSpinBox()
self.spinbox3DMargin.setRange(50, 1000)
self.spinbox3DMargin.setValue(100)
self.spinbox3DMargin.setSingleStep(10)
hBox3D.addWidget(self.spinbox3DMargin)
labelSpace = QLabel(' ')
hBox3D.addWidget(labelSpace)
label3DElevationScale = QLabel('Elev. scale')
hBox3D.addWidget(label3DElevationScale)
self.spinbox3DElevationScale = QDoubleSpinBox()
self.spinbox3DElevationScale.setRange(1, 50)
self.spinbox3DElevationScale.setSingleStep(0.1)
hBox3D.addWidget(self.spinbox3DElevationScale)
hBox3D.addWidget(labelSpace)
label3DOSMZoom = QLabel('Zoom')
hBox3D.addWidget(label3DOSMZoom)
self.spinbox3DOSMZoom = QSpinBox()
self.spinbox3DOSMZoom.setRange(8, 15)
self.spinbox3DOSMZoom.setValue(13)
self.spinbox3DOSMZoom.setSingleStep(1)
hBox3D.addWidget(self.spinbox3DOSMZoom)
hBox3D.addWidget(labelSpace)
self.check3DOSMInvert = QCheckBox("Invert")
self.check3DOSMInvert.setChecked(False)
hBox3D.addWidget(self.check3DOSMInvert)
vBox2.addLayout(hBox3D)
vBox_left.addLayout(vBox2)
# 3rd stats tree
lineTree = QFrame()
lineTree.setFrameShape(QFrame.HLine)
lineTree.setFrameShadow(QFrame.Sunken)
vBox2.addWidget(lineTree)
labelTree = QLabel('Track stats')
vBox2.addWidget(labelTree)
self.tree = QTreeView()
self.tree.setSelectionBehavior(QAbstractItemView.SelectRows)
self.treemodel = QtGui.QStandardItemModel()
self.treemodel.setHorizontalHeaderLabels(['Name', 'Value'])
self.tree.setModel(self.treemodel)
self.tree.setUniformRowHeights(True)
self.tree.setColumnWidth(0, 200)
vBox_left.addWidget(self.tree)
# 4th text, containing text messages/errors
self.textWarningConsole = QTextEdit()
self.textWarningConsole.setReadOnly(True)
self.textWarningConsole.setFont(QtGui.QFont("Courier New", FONTSIZE))
self.textWarningConsole.clear()
self.textWarningConsole.setMaximumHeight(50)
vBox_left.addWidget(self.textWarningConsole)
# I put "vBox_left" inside a widget and then the widget inside "hBox"
# instead of just doing "hBox.addLayout(vBox_left) so I can set its
# maximum width.
vBox_left_widget = QWidget()
vBox_left_widget.setLayout(vBox_left)
vBox_left_widget.setMinimumWidth(400)
vBox_left_widget.setMaximumWidth(500)
hBox.addWidget(vBox_left_widget)
# Vertical right column
self.tab = QTabWidget()
# Tab 1: Summary: elevation and speed
tab1 = QWidget()
# The tab layout
vBox_tab = QVBoxLayout()
vBox_tab.setSpacing(5)
# Plot area
self.plotEmbeddedElevationAndSpeed = EmbeddedPlot_ElevationSpeed(
width=5, height=4, dpi=100)
self.plotEmbeddedElevationAndSpeed.setMinimumWidth(800)
# Add toolbar to the plot
self.mpl_toolbar1 = NavigationToolbar(
self.plotEmbeddedElevationAndSpeed, self.scatola)
# Add widgets to the layout
vBox_tab.addWidget(self.plotEmbeddedElevationAndSpeed)
vBox_tab.addWidget(self.mpl_toolbar1)
# Associate the layout to the tab
tab1.setLayout(vBox_tab)
# Tab 2: html 2D map
tab2 = QWidget()
# The tab layout
vBox_tab = QVBoxLayout()
vBox_tab.setSpacing(5)
# Area
self.map2d = QtWebEngineWidgets.QWebEngineView()
# Add widgets to the layout
vBox_tab.addWidget(self.map2d)
# Associate the layout to the tab
tab2.setLayout(vBox_tab)
# Tab 3: 3D plot
tab3 = QWidget()
# The tab layout
vBox_tab = QVBoxLayout()
vBox_tab.setSpacing(5)
# Area
self.map3d = MayaviQWidget()
# Add widgets to the layout
vBox_tab.addWidget(self.map3d)
# Associate the layout to the tab
tab3.setLayout(vBox_tab)
# Tab 4: Details
tab4 = QWidget()
# The tab layout
vBox_tab = QVBoxLayout()
vBox_tab.setSpacing(5)
# Plot area
self.plotEmbeddedDetails = EmbeddedPlot_Details(width=5,
height=4,
dpi=100)
self.plotEmbeddedDetails.setMinimumWidth(800)
# Add toolbar to the plot
self.mpl_toolbar2 = NavigationToolbar(self.plotEmbeddedDetails,
self.scatola)
# Add widgets to the layout
vBox_tab.addWidget(self.plotEmbeddedDetails)
vBox_tab.addWidget(self.mpl_toolbar2)
# Associate the layout to the tab
tab4.setLayout(vBox_tab)
# Associate tabs
self.tab.addTab(tab1, "Summary")
self.tab.addTab(tab2, "2D Map")
self.tab.addTab(tab3, "3D Map")
self.tab.addTab(tab4, "Details")
hBox.addWidget(self.tab)
# Setting hBox as main box
self.scatola.setLayout(hBox)
self.setCentralWidget(self.scatola)
# Application settings
self.setWindowTitle('TrackAnalyser')
self.setWindowIcon((QtGui.QIcon('icons/app.png')))
self.setGeometry(100, 100, 1200, 700)
self.show()
try:
import numpy as np
except ImportError:
np = None
from mfixgui.project import Equation, Keyword, make_FloatExp
from mfixgui.regexes import *
from mfixgui.constants import *
from mfixgui.tools.qt import get_icon
from mfixgui.tools import get_unique_string
from mfixgui.tools.simpleeval import VALID_EXPRESION_NAMES
VALID_EXP_NAMES = VALID_EXPRESION_NAMES + SPECIAL_PARAMETERS
SETTINGS = QtCore.QSettings('MFIX', 'MFIX')
ANIMATION_SPEED = int(SETTINGS.value('animation_speed', 400))
def insert_append_action(menu, action, insert=None):
if insert:
menu.insertAction(insert, action)
else:
menu.addAction(action)
def insert_append_separator(menu, insert=None):
if insert:
menu.insertSeparator(insert)
else:
menu.addSeparator()
glActiveTexture(GL_TEXTURE0)
elements.tex_vertices.bind()
u.set('mesh.vertices', 0)
u.set('mesh.dim', elements.dim);
u.set('mesh.offset', elements.offset);
if elements.dim>0:
glActiveTexture(GL_TEXTURE1)
elements.tex.bind()
u.set('mesh.elements', 1)
check_debug_output()
return prog
getProgram._cache = {}
getProgram._settings = QtCore.QSettings('ngsolve','shaders')
class VertexArray(GLObject):
def __init__(self):
self._id = glGenVertexArrays(1)
def __enter__(self):
self.__prev_id = glGetInteger(GL_VERTEX_ARRAY_BINDING)
glBindVertexArray(self.id)
return self
def __exit__(self, *args):
glBindVertexArray(self.__prev_id)
def bind(self):
glBindVertexArray(self.id)
