def __init__(self, spec, shutter, experiment, parent=None):
super(DumbIrradiationExperiment_Gui, self).__init__(parent)
#Load ui code
uic.loadUi('DumbIrradiationExperimentGui.ui', self)
#grabbing the current H5PY and intiating the data_browser
self.data_file = nplab.current_datafile()
self.data_file_tab = self.replace_widget(self.DataBrowser_tab_layout,
self.DataBrowser_widget,
self.data_file.get_qt_ui())
#setup spectrometer tab gui and widget
self.spectrometer = spec
self.Spectrometer_widget = self.replace_widget(
self.Spectrometer_Layout, self.Spectrometer_widget,
self.spectrometer.get_qt_ui(display_only=True))
self.spectrometer_tab = self.replace_widget(
self.Spectrometer_tab_Layout, self.Spectrometer_tab_widget,
self.spectrometer.get_qt_ui())
#Setting up stepper and Lockin widget
# Display
self.Experiment = experiment
self.Experiment_controls_widget = self.replace_widget(
self.Main_layout, self.Experiment_controls_widget,
self.Experiment.get_qt_ui())
#Shutter control widget
self.shutter = shutter
self.StageControls_widget = self.replace_widget(
self.Main_layout, self.shutter_controls_widget,
self.shutter.get_qt_ui())
def __init__(self, grid_scanner, parent=None):
assert isinstance(grid_scanner, HyperspectralScan), \
'scanner must be an instance of HyperspectralScan'
super(HyperspectralScanUI, self).__init__()
self.grid_scanner = grid_scanner
uic.loadUi(
os.path.join(os.path.dirname(__file__),
'hyperspectral_imaging.ui'), self)
self.gridscanner_widget = self.replace_widget(
self.main_layout, self.gridscanner_widget,
GridScanQt.get_qt_ui_cls()(self.grid_scanner))
self.gridscanner_widget.rate = 1. / 20.
self.grid_scanner.fig = Figure() # pg.GraphicsLayoutWidget()
# self.grid_scanner.fig.scene().sigMouseClicked.connect(self.grid_scanner.on_mouse_click)
self.figure_widget = self.replace_widget(
self.main_layout, self.figure_widget,
FigureCanvas(self.grid_scanner.fig))
self.init_stage_select()
self.init_view_wavelength_controls()
self.init_view_select()
self.scan_description.textChanged.connect(self.update_param)
self.safe_exit.stateChanged.connect(self.on_state_change)
self.config_stage.clicked.connect(self.on_click)
self.config_spectrometers.clicked.connect(self.on_click)
self.config_light_source.clicked.connect(self.on_click)
self.open_browser.clicked.connect(self.on_click)
def __init__(self, flipper, parent=None):
assert isinstance(flipper, Flipper), 'instrument must be a flipper'
self.flipper = flipper
super(flipperUI, self).__init__(parent)
uic.loadUi(os.path.join(os.path.dirname(__file__), 'flipper.ui'), self)
self.auto_connect_by_name(controlled_object=self.flipper,
verbose=False)
def __init__(self, smu, parent=None):
super(SmuUI, self).__init__()
self.smu = smu
self.parent = parent
uic.loadUi(os.path.join(os.path.dirname(__file__), 'smu.ui'), self)
self.current_button.clicked.connect(self.state_changed)
self.voltage_button.clicked.connect(self.state_changed)
self.source_value.returnPressed.connect(self.set_parameter)
self.source_range.returnPressed.connect(self.set_parameter)
self.source_autorange.stateChanged.connect(self.state_changed)
self.source_limit.returnPressed.connect(self.set_parameter)
self.measurement_range.returnPressed.connect(self.set_parameter)
self.measurement_autorange.stateChanged.connect(self.state_changed)
self.measurement_limit.returnPressed.connect(self.set_parameter)
self.measure_button.clicked.connect(self.measure_button_clicked)
self.display_select.activated[str].connect(self.on_activated)
self.output.stateChanged.connect(self.state_changed)
self.voltage_button.setChecked(True)
self.source_value.setText(str(self.smu.src_voltage))
self.source_range.setText(str(self.smu.src_voltage_range))
self.source_autorange.setChecked(bool(self.smu.src_voltage_autorange))
self.source_limit.setText(str(self.smu.src_voltage_limit))
self.measurement_range.setText(str(self.smu.meas_current_range))
self.measurement_autorange.setChecked(
bool(self.smu.meas_current_autorange))
self.measurement_limit.setText(str(self.smu.src_current_limit))
self.output.setChecked(False)
def __init__(self, andor):
assert isinstance(andor, Andor), "instrument must be an Andor"
super(AndorUI, self).__init__()
self.Andor = andor
self.DisplayWidget = None
self.temperature_display_thread = DisplayThread(self)
uic.loadUi((os.path.dirname(__file__) + '/andor.ui'), self)
self._setup_signals()
self.init_gui()
self.binning()
self.data_file = None
self.save_all_parameters = False
self.gui_params = [
'ReadMode', 'Exposure', 'AcquisitionMode', 'OutAmp', 'TriggerMode'
]
self._func_dict = {}
for param in self.gui_params:
func = self.callback_to_update_prop(param)
self._func_dict[param] = func
register_for_property_changes(self.Andor, param,
self._func_dict[param])
if self.Andor.SingleTrack is not None:
c_row, n_rows = self.Andor.SingleTrack
self.spinBoxCenterRow.setValue(c_row)
self.spinBoxNumRows.setValue(n_rows)
def load_ui_from_file(self, current_file, filename):
"""Load a form from a Qt Designer file, into the current object.
Usually current_file should just be __file__, if the ui file is located
in the same directory as the python module you're writing. Filename
is the UI file."""
uic.loadUi(os.path.join(os.path.dirname(current_file), filename), self)
def __init__(self,
spectrometer,
ui_file=os.path.join(os.path.dirname(__file__),
'spectrometer_controls.ui'),
parent=None):
assert isinstance(spectrometer,
Spectrometer), "instrument must be a Spectrometer"
super(SpectrometerControlUI, self).__init__()
uic.loadUi(ui_file, self)
self.spectrometer = spectrometer
self.integration_time.setValidator(QtGui.QDoubleValidator())
self.integration_time.textChanged.connect(self.check_state)
self.integration_time.textChanged.connect(self.update_param)
self.read_background_button.clicked.connect(self.button_pressed)
self.read_reference_button.clicked.connect(self.button_pressed)
self.clear_background_button.clicked.connect(self.button_pressed)
self.clear_reference_button.clicked.connect(self.button_pressed)
self.load_state_button.clicked.connect(self.button_pressed)
self.background_subtracted.stateChanged.connect(self.state_changed)
self.referenced.stateChanged.connect(self.state_changed)
self.Absorption_checkBox.stateChanged.connect(self.state_changed)
register_for_property_changes(self.spectrometer,
'variable_int_enabled',
self.variable_int_state_change)
# if self.spectrometer.variable_int_enabled:
# self.background_subtracted.blockSignals(True)
# self.background_subtracted.setCheckState(QtCore.Qt.Checked)
# self.background_subtracted.blockSignals(False)
self.Variable_int.stateChanged.connect(self.state_changed)
# if self.spectrometer.variable_int_enabled:
# self.background_subtracted.blockSignals(True)
# self.background_subtracted.setCheckState(QtCore.Qt.Checked)
# self.background_subtracted.blockSignals(False)
self.average_checkBox.stateChanged.connect(self.state_changed)
self.Average_spinBox.valueChanged.connect(self.update_averages)
self.referenceID_spinBox.valueChanged.connect(self.update_references)
self.id_string.setText('{0} {1}'.format(
self.spectrometer.model_name, self.spectrometer.serial_number))
self.id_string.resize(self.id_string.sizeHint())
self.integration_time.setText(str(spectrometer.integration_time))
self.num_spectra_spinBox.valueChanged.connect(
self.update_time_series_params)
self.delay_doubleSpinBox.valueChanged.connect(
self.update_time_series_params)
self.time_series_name_lineEdit.textChanged.connect(
self.update_time_series_name)
self.time_series_pushButton.clicked.connect(self.time_series)
def __init__(self, fw):
super(FW212C_UI, self).__init__()
self.fw = fw
uic.loadUi(
os.path.join(os.path.dirname(__file__), 'thorlabs_fw212c.ui'),
self)
for button in range(1, 13): #1-12
eval('self.radioButton_' + str(button) +
'.clicked.connect(self.button_pressed)')
def __init__(self, pm):
super(PowerMeterUI, self).__init__()
uic.loadUi(os.path.join(os.path.dirname(__file__), 'power_meter.ui'),
self)
self.pm = pm
self.update_condition = threading.Condition()
self.display_thread = DisplayThread(self)
self.SetupSignals()
register_for_property_changes(self.pm, 'live', self.live_changed)
def __init__(self, triax):
assert isinstance(triax, Triax), "instrument must be a Triax550"
super(TriaxUI, self).__init__()
uic.loadUi(os.path.join(os.path.dirname(__file__), 'Triax.ui'), self)
self.lineEditTriaxWL.returnPressed.connect(self.txtChangedTriaxWL)
self.lineEditSlitWidth.returnPressed.connect(self.txtChangedSlitWidth)
self.pushButtonTriaxReset.clicked.connect(self.btnClickedTriaxReset)
self.Triax = triax
self.updateGUI()
def __init__(self, mcs, parent=None):
assert isinstance(mcs, SmaractMCS) or isinstance(mcs, SmaractMCSSerial) , "system must be a Smaract MCS"
super(SmaractMCSUI, self).__init__()
self.mcs = mcs
uic.loadUi(os.path.join(os.path.dirname(__file__), 'smaract_mcs.ui'), self)
self.mcs_id.setText(str(mcs.mcs_id))
self.num_ch.setText(str(mcs.num_ch))
self.reference_button.clicked.connect(self.mcs.find_references)
self.calibrate_button.clicked.connect(self.mcs.calibrate_system)
self.step_stage_widget = self.replace_widget(self.step_stage_layout, self.step_stage_widget, SmaractStageUI(self.mcs))
self.scan_stage_widget = self.replace_widget(self.scan_stage_layout, self.scan_stage_widget, SmaractScanStageUI(self.mcs))
def __init__(self, itc):
assert isinstance(itc, OxfordITC), "instrument must be an Oxford ITC"
super(OxfordITCUI, self).__init__()
self.ITC = itc
uic.loadUi(os.path.join(os.path.dirname(__file__), 'OxfordITC.ui'), self)
self.lineEditSetT.returnPressed.connect(self.setT)
self.updateGUI.connect(self.SentUpdateGUI)
self.SentUpdateGUI()
def __init__(self, triax, ui_file =os.path.join(os.path.dirname(__file__),'triax_ui.ui'), parent=None):
assert isinstance(triax, Triax), "instrument must be a Triax"
super(TriaxUI, self).__init__()
uic.loadUi(ui_file, self)
self.triax = triax
self.centre_wl_lineEdit.returnPressed.connect(self.set_wl_gui)
self.slit_lineEdit.returnPressed.connect(self.set_slit_gui)
wl_arr = self.triax.Get_Wavelength_Array()
self.centre_wl_lineEdit.setText(str(np.around(wl_arr[len(wl_arr)//2])))
self.slit_lineEdit.setText(str(self.triax.Slit()))
eval('self.grating_'+str(self.triax.Grating())+'_radioButton.setChecked(True)')
for radio_button in range(3):
eval('self.grating_'+str(radio_button)+'_radioButton.clicked.connect(self.set_grating_gui)')
def __init__(self, stage, parent=None, stage_step_min=1e-9, stage_step_max=1e-3, default_step=1e-6):
assert isinstance(stage, Stage), "instrument must be a Stage"
super(StageUI, self).__init__()
self.stage = stage
#self.setupUi(self)
uic.loadUi(os.path.join(os.path.dirname(__file__), 'stage.ui'), self)
self.step_size_values = step_size_dict(stage_step_min, stage_step_max,unit = self.stage.unit)
self.step_size = [self.step_size_values[self.step_size_values.keys()[0]] for axis in stage.axis_names]
self.create_axes_layout(default_step)
self.update_ui[int].connect(self.update_positions)
self.update_ui[str].connect(self.update_positions)
self.update_pos_button.clicked.connect(partial(self.update_positions, None))
self.update_positions()
def __init__(self,
spectrometer,
ui_file=os.path.join(os.path.dirname(__file__),
'spectrometer_view.ui'),
parent=None):
assert isinstance(spectrometer, Spectrometer) or isinstance(spectrometer, Spectrometers),\
"instrument must be a Spectrometer or an instance of Spectrometers"
super(SpectrometerDisplayUI, self).__init__()
uic.loadUi(ui_file, self)
if isinstance(spectrometer,
Spectrometers) and spectrometer.num_spectrometers == 1:
spectrometer = spectrometer.spectrometers[0]
if isinstance(spectrometer, Spectrometer):
spectrometer.num_spectrometers = 1
self.spectrometer = spectrometer
print(self.spectrometer)
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
self.plotbox = QtWidgets.QGroupBox()
self.plotbox.setLayout(QtWidgets.QGridLayout())
self.plotlayout = self.plotbox.layout()
self.plots = []
for spectrometer_nom in range(self.spectrometer.num_spectrometers):
self.plots.append(
pg.PlotWidget(labels={'bottom': 'Wavelength (nm)'}))
self.plotlayout.addWidget(self.plots[spectrometer_nom])
self.figure_widget = self.replace_widget(self.display_layout,
self.figure_widget,
self.plotbox)
self.take_spectrum_button.clicked.connect(self.button_pressed)
self.live_button.clicked.connect(self.button_pressed)
self.save_button.clicked.connect(self.button_pressed)
self.threshold.setValidator(QtGui.QDoubleValidator())
self.threshold.textChanged.connect(self.check_state)
self._display_thread = DisplayThread(self)
self._display_thread.spectrum_ready.connect(self.update_display)
self._display_thread.spectra_ready.connect(self.update_display)
self.period = 0.2
self.filename_lineEdit.textChanged.connect(self.filename_changed_ui)
register_for_property_changes(self.spectrometer, 'filename',
self.filename_changed)
def __init__(self, stepper):
super(Stepper_Ui, self).__init__()
# assert(stepper==Stepper) # checking if the object is a stepper
self.stepper = stepper
ui_file = os.path.join(
os.path.dirname(__file__), 'stepper_GUI.ui'
) # GUI path . e.g. look into location of the current file and search for the given name
uic.loadUi(ui_file, self) #loading the ui file
self.move_spinBox.setMaximum(int(self.stepper.max_steps))
self.move_percent_doubleSpinBox.setMaximum(100.0)
self.current_button.clicked.connect(self.update_positions)
self.setpercent_pushButton.clicked.connect(self.move_to_percent)
self.setsteps_pushButton.clicked.connect(self.move_to)
self.update_positions()
def __init__(self, streak):
super(StreakUI, self).__init__()
self.Streak = streak
uic.loadUi((os.path.dirname(__file__) + '/Streak.ui'), self)
self.comboBoxGateMode.activated.connect(self.gate_mode)
self.comboBoxReadMode.activated.connect(self.read_mode)
self.comboBoxShutter.activated.connect(self.shutter)
self.comboBoxTrigMode.activated.connect(self.trigger)
self.spinBox_MCPGain.valueChanged.connect(self.mcp_gain)
self.lineEditTimeRange.returnPressed.connect(self.time_range)
self.comboBoxTimeUnit.activated.connect(self.time_range)
self.pushButtonLess.clicked.connect(lambda: self.time_range('-'))
self.pushButtonMore.clicked.connect(lambda: self.time_range('+'))
self.pushButtonCapture.clicked.connect(
lambda: self.Streak.raw_image(update_latest_frame=True))
def __init__(self, light_source, parent=None):
assert isinstance(light_source,
LightSource), 'instrument must be a LightSource'
self.light_source = light_source
super(LightSourceUI, self).__init__(parent)
uic.loadUi(os.path.join(os.path.dirname(__file__), 'light_source.ui'),
self)
self.control_group.setTitle(self.light_source.__class__.__name__)
self.power.setValidator(QtGui.QDoubleValidator())
self.power.textChanged.connect(self.check_state)
self.power.returnPressed.connect(self.update_param)
self.power_slider.setRange(self.light_source.min_power,
self.light_source.max_power)
self.power_slider.valueChanged[int].connect(self.update_param)
self.power_slider.sliderReleased.connect(self.update_param)
self.set_power_button.clicked.connect(self.on_click)
if self.light_source.shutter is not None:
self.control_layout.addWidget(
self.light_source.shutter.get_qt_ui())
def __init__(self, solstis):
assert isinstance(solstis, SolsTiS), "instrument must be a SolsTiS"
super(SolsTiSUI, self).__init__()
self.SolsTiS = solstis
self.signal = QtCore.SIGNAL('SolsTiSGUIupdate')
self.SolsTiSMonitorThread = None
uic.loadUi(os.path.join(os.path.dirname(__file__), 'SolsTiS.ui'), self)
self.checkBoxSolsTiSLockMonitor.stateChanged.connect(
self.SolsTiSLockMonitor)
self.checkBoxSolsTiSEtalonLock.stateChanged.connect(
self.SolsTiSLockEtalon)
self.checkBoxSolsTiSCavityLock.stateChanged.connect(
self.SolsTiSLockCavity)
self.lineEditSolsTiSWL.returnPressed.connect(self.SolsTiSWL)
self.pushButtonSolsTiSstatusMonitor.clicked.connect(
self.SolsTiSMonitor)
self.pushButtonSolsTiSstopMonitor.clicked.connect(
self.SolsTiSMonitorStop)
def setup_gui(self):
"""Creates a DockArea and fills it with the Slm.options given
For each option, it extracts the correct ui from gui by name, loads it into a widget and adds it to the DockArea
:return:
"""
uic.loadUi(os.path.join(os.path.dirname(__file__), 'ui_base.ui'), self)
self.dockarea = dockarea.DockArea()
self.splitter.insertWidget(0, self.dockarea)
self.dockarea.show() # Absolutely no idea why this is needed
self.all_widgets = dict()
self.all_docks = []
for option in self.SLM.options:
widget = getattr(gui, '%sUi' % option)(self)
dock = dockarea.Dock(option)
dock.addWidget(widget)
self.dockarea.addDock(dock, 'bottom')
self.all_widgets[option] = widget
self.all_docks += [dock]
self.make_pushButton.pressed.connect(self.make)
def create_axes_layout(self,
default_step=1e-6,
stack_multiple_stages='horizontal'):
uic.loadUi(os.path.join(os.path.dirname(__file__), 'stage.ui'), self)
self.update_pos_button.clicked.connect(
partial(self.update_positions, None))
path = os.path.dirname(os.path.realpath(nplab.ui.__file__))
icon_size = QtCore.QSize(12, 12)
self.positions = []
self.set_positions = []
self.set_position_buttons = []
for i, ax in enumerate(self.stage.axis_names):
col = 4 * (i / 3)
position = QtWidgets.QLineEdit('', self)
position.setReadOnly(True)
self.positions.append(position)
set_position = QtWidgets.QLineEdit('0', self)
set_position.setMinimumWidth(40)
self.set_positions.append(set_position)
set_position_button = QtWidgets.QPushButton('', self)
set_position_button.setIcon(
QtGui.QIcon(os.path.join(path, 'go.png')))
set_position_button.setIconSize(icon_size)
set_position_button.resize(icon_size)
set_position_button.clicked.connect(self.button_pressed)
self.set_position_buttons.append(set_position_button)
# for each stage axis add a label, a field for the current position,
# a field to set a new position and a button to set a new position ..
self.info_layout.addWidget(QtWidgets.QLabel(str(ax), self), i % 3,
col)
self.info_layout.addWidget(position, i % 3, col + 1)
self.info_layout.addWidget(set_position, i % 3, col + 2)
self.info_layout.addWidget(set_position_button, i % 3, col + 3)
if i % 3 == 0:
group = QtWidgets.QGroupBox('axes {0}'.format(1 + (i / 3)),
self)
layout = QtWidgets.QGridLayout()
layout.setSpacing(3)
group.setLayout(layout)
self.axes_layout.addWidget(group, 0, i / 3)
zero_button = QtWidgets.QPushButton('', self)
zero_button.setIcon(QtGui.QIcon(os.path.join(path,
'zero.png')))
zero_button.setIconSize(icon_size)
zero_button.resize(icon_size)
n = len(self.stage.axis_names) - i if len(
self.stage.axis_names) - i < 3 else 3
axes_set = self.stage.axis_names[i:i + n]
# zero_button.clicked.connect(partial(self.zero_all_axes, axes_set))
layout.addWidget(zero_button, 1, 1)
step_size_select = QtWidgets.QComboBox(self)
step_size_select.addItems(self.step_size_values.keys())
step_size_select.activated[str].connect(
partial(self.on_activated, i))
step_str = engineering_format(default_step, self.stage.unit)
step_index = self.step_size_values.keys().index(step_str)
step_size_select.setCurrentIndex(step_index)
layout.addWidget(QtWidgets.QLabel(str(ax), self), i % 3, 5)
layout.addWidget(step_size_select, i % 3, 6)
if i % 3 == 0:
layout.addItem(QtWidgets.QSpacerItem(12, 0), 0, 4)
plus_button = QtWidgets.QPushButton('', self)
plus_button.clicked.connect(
partial(self.move_axis_relative, i, ax, 1))
minus_button = QtWidgets.QPushButton('', self)
minus_button.clicked.connect(
partial(self.move_axis_relative, i, ax, -1))
if i % 3 == 0:
plus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'right.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'left.png')))
layout.addWidget(minus_button, 1, 0)
layout.addWidget(plus_button, 1, 2)
elif i % 3 == 1:
plus_button.setIcon(QtGui.QIcon(os.path.join(path, 'up.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'down.png')))
layout.addWidget(plus_button, 0, 1)
layout.addWidget(minus_button, 2, 1)
elif i % 3 == 2:
plus_button.setIcon(QtGui.QIcon(os.path.join(path, 'up.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'down.png')))
layout.addWidget(plus_button, 0, 3)
layout.addWidget(minus_button, 2, 3)
plus_button.setIconSize(icon_size)
plus_button.resize(icon_size)
minus_button.setIconSize(icon_size)
minus_button.resize(icon_size)
def __init__(self, slm_gui, name):
super(BaseUi, self).__init__()
uic.loadUi(os.path.join(os.path.dirname(__file__), 'ui_%s.ui' % name),
self)
self.slm_gui = slm_gui
self._connect()
def __init__(self,
instrument_dict,
parent=None,
dock_settings_path=None,
scripts_path=None,
working_directory=None):
super(GuiGenerator, self).__init__(parent)
self._logger = LOGGER
self.instr_dict = instrument_dict
if working_directory == None:
self.working_directory = os.path.join(os.getcwd())
else:
self.working_directory = working_directory
self.data_file = df.current(working_directory=working_directory)
self.instr_dict['HDF5'] = self.data_file
self.setDockNestingEnabled(1)
uic.loadUi(os.path.join(os.path.dirname(__file__), 'guigenerator.ui'),
self)
self.allDocks = {}
self.allWidgets = {}
self.actions = dict(Views={}, Instruments={})
self.dockwidgetArea = pyqtgraph.dockarea.DockArea()
self.dockWidgetArea = self.replace_widget(self.verticalLayout,
self.centralWidget(),
self.dockwidgetArea)
self.dockWidgetAllInstruments.setWidget(self.dockwidgetArea)
self.dockWidgetAllInstruments.setTitleBarWidget(
QtWidgets.QWidget()) # This trick makes the title bar disappear
# Iterate over all the opened instruments. If the instrument has a GUI (i.e. if they have the get_qt_ui function
# defined inside them), then create a pyqtgraph.Dock for it and add its widget to the Dock. Also prints out any
# instruments that do not have GUIs
self._logger.info('Opening all GUIs')
for instr in self.instr_dict:
self._open_one_gui(instr)
self.terminalWindow = None
self.menuTerminal()
self._addActionViewMenu('Terminal')
self.script_menu = None
if scripts_path is not None:
self.scripts_path = scripts_path
else:
self.scripts_path = 'scripts'
self.makeScriptMenu()
self.NightMode = 1
# address of h5 file
self.filename = df.current().filename
# self._tabifyAll()
self._setupSignals()
if dock_settings_path is not None:
self.dock_settings_path = dock_settings_path
self.menuLoadSettings()
else:
self.dock_settings_path = None
self.showMaximized()
def create_axes_layout(self,
default_step=1e-8,
stack_multiple_stages='horizontal'):
uic.loadUi(os.path.join(os.path.dirname(__file__), 'piezo_stage.ui'),
self)
path = os.path.dirname(os.path.realpath(nplab.ui.__file__))
icon_size = QtCore.QSize(12, 12)
self.position_widgets = []
self.xy_positions = []
self.set_positions = []
self.set_position_buttons = []
for i, ax in enumerate(self.stage.axis_names):
col = 4 * (old_div(i, 3))
if i % 3 == 0:
# absolute position for different stages consisting of 3 axes
position_widget = XYZPositionWidget(
self.stage.max_voltage_levels[old_div(i, 3)],
self.stage.max_voltage_levels[old_div(i, 3) + 1],
self.stage.max_voltage_levels[old_div(i, 3) + 2],
show_xy_pos=self.show_xy_pos,
show_z_pos=self.show_z_pos)
if self.show_xy_pos:
xy_position = position_widget.xy_widget.crosshair
xy_position.CrossHairMoved.connect(self.crosshair_moved)
self.xy_positions.append(xy_position)
self.position_widgets.append(position_widget)
self.info_layout.addWidget(position_widget, 0, col, 3, 1)
# position control elements for different stages consisting of 3 axes, arranged in a grid layout
group = QtWidgets.QGroupBox(
'stage {0}'.format(1 + (old_div(i, 3))), self)
layout = QtWidgets.QGridLayout()
layout.setSpacing(3)
group.setLayout(layout)
self.axes_layout.addWidget(group, 0, old_div(i, 3))
zero_button = QtWidgets.QPushButton('', self)
zero_button.setIcon(QtGui.QIcon(os.path.join(path,
'zero.png')))
zero_button.setIconSize(icon_size)
zero_button.resize(icon_size)
n = len(self.stage.axis_names) - i if len(
self.stage.axis_names) - i < 3 else 3
#axes_set = self.stage.axis_names[i:i + n]
#zero_button.clicked.connect(partial(self.zero_all_axes, axes_set))
layout.addWidget(zero_button, 1, 1)
set_position = QtWidgets.QLineEdit(
'0', self) # text field to set position
set_position.setMinimumWidth(40)
set_position.setReadOnly(True)
self.set_positions.append(set_position)
set_position_button = QtWidgets.QPushButton('', self)
set_position_button.setIcon(
QtGui.QIcon(os.path.join(path, 'go.png')))
set_position_button.setIconSize(icon_size)
set_position_button.resize(icon_size)
set_position_button.clicked.connect(self.button_pressed)
self.set_position_buttons.append(set_position_button)
# for each stage axis add a label, a field for the current position,
# a field to set a new position and a button to set a new position ..
self.info_layout.addWidget(QtWidgets.QLabel(str(ax), self), i % 3,
col + 1)
self.info_layout.addWidget(set_position, i % 3, col + 2)
self.info_layout.addWidget(set_position_button, i % 3, col + 3)
step_size_select = QtWidgets.QComboBox(self)
step_size_select.addItems(list(self.step_size_values.keys()))
step_size_select.activated[str].connect(
partial(self.on_activated, i))
step_str = engineering_format(default_step, self.stage.unit)
step_index = list(self.step_size_values.keys()).index(step_str)
step_size_select.setCurrentIndex(step_index)
layout.addWidget(QtWidgets.QLabel(str(ax), self), i % 3, 5)
layout.addWidget(step_size_select, i % 3, 6)
if i % 3 == 0:
layout.addItem(QtWidgets.QSpacerItem(12, 0), 0, 4)
plus_button = QtWidgets.QPushButton('', self)
plus_button.clicked.connect(
partial(self.move_axis_relative, i, ax, 1))
minus_button = QtWidgets.QPushButton('', self)
minus_button.clicked.connect(
partial(self.move_axis_relative, i, ax, -1))
if i % 3 == 0:
plus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'right.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'left.png')))
layout.addWidget(minus_button, 1, 0)
layout.addWidget(plus_button, 1, 2)
elif i % 3 == 1:
plus_button.setIcon(QtGui.QIcon(os.path.join(path, 'up.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'down.png')))
layout.addWidget(plus_button, 0, 1)
layout.addWidget(minus_button, 2, 1)
elif i % 3 == 2:
plus_button.setIcon(QtGui.QIcon(os.path.join(path, 'up.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'down.png')))
layout.addWidget(plus_button, 0, 3)
layout.addWidget(minus_button, 2, 3)
plus_button.setIconSize(icon_size)
plus_button.resize(icon_size)
minus_button.setIconSize(icon_size)
minus_button.resize(icon_size)
def create_axes_layout(self,
default_step=1e-6,
arrange_buttons='cross',
rows=None):
"""Layout of the PyQt widgets for absolute and relative movement of all axis
:param default_step:
:param arrange_buttons: either 'cross' or 'stack'. If 'cross', assumes the stages axes are x,y,z movement,
placing the arrows in an intuitive cross pattern
:param rows: number of rows per column when distributing the QtWidgets
:return:
"""
if rows is None:
rows = np.ceil(np.sqrt(len(self.stage.axis_names)))
rows = int(
rows) # int is needed for the old_div and the modulo operations
uic.loadUi(os.path.join(os.path.dirname(__file__), 'stage.ui'), self)
self.update_pos_button.clicked.connect(
partial(self.update_positions, None))
path = os.path.dirname(os.path.realpath(nplab.ui.__file__))
icon_size = QtCore.QSize(12, 12)
self.positions = []
self.set_positions = []
self.set_position_buttons = []
for i, ax in enumerate(self.stage.axis_names):
col = 4 * (old_div(i, rows))
position = QtWidgets.QLineEdit('', self)
position.setReadOnly(True)
self.positions.append(position)
set_position = QtWidgets.QLineEdit('0', self)
set_position.setMinimumWidth(40)
self.set_positions.append(set_position)
set_position_button = QtWidgets.QPushButton('', self)
set_position_button.setIcon(
QtGui.QIcon(os.path.join(path, 'go.png')))
set_position_button.setIconSize(icon_size)
set_position_button.resize(icon_size)
set_position_button.clicked.connect(self.button_pressed)
self.set_position_buttons.append(set_position_button)
# for each stage axis add a label, a field for the current position,
# a field to set a new position and a button to set a new position ..
self.info_layout.addWidget(QtWidgets.QLabel(str(ax), self),
i % rows, col)
self.info_layout.addWidget(position, i % rows, col + 1)
self.info_layout.addWidget(set_position, i % rows, col + 2)
self.info_layout.addWidget(set_position_button, i % rows, col + 3)
if i % rows == 0:
if arrange_buttons == 'cross':
group = QtWidgets.QGroupBox(
'axes {0}'.format(1 + (old_div(i, rows))), self)
layout = QtWidgets.QGridLayout()
layout.setSpacing(3)
group.setLayout(layout)
self.axes_layout.addWidget(group, 0, old_div(i, rows))
offset = 0
elif arrange_buttons == 'stack':
layout = self.axes_layout
offset = 7 * old_div(i, rows)
else:
raise ValueError('Unrecognised arrangment: %s' %
arrange_buttons)
step_size_select = QtWidgets.QComboBox(self)
step_size_select.addItems(list(self.step_size_values.keys()))
step_size_select.activated[str].connect(
partial(self.on_activated, i))
step_str = engineering_format(default_step, self.stage.unit)
step_index = list(self.step_size_values.keys()).index(step_str)
step_size_select.setCurrentIndex(step_index)
layout.addWidget(QtWidgets.QLabel(str(ax), self), i % rows,
5 + offset)
layout.addWidget(step_size_select, i % rows, 6 + offset)
if i % 3 == 0 and arrange_buttons == 'cross':
layout.addItem(QtWidgets.QSpacerItem(12, 0), 0, 4)
plus_button = QtWidgets.QPushButton('', self)
plus_button.clicked.connect(
partial(self.move_axis_relative, i, ax, 1))
minus_button = QtWidgets.QPushButton('', self)
minus_button.clicked.connect(
partial(self.move_axis_relative, i, ax, -1))
if arrange_buttons == 'cross':
if i % rows == 0:
plus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'right.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'left.png')))
layout.addWidget(minus_button, 1, 0)
layout.addWidget(plus_button, 1, 2)
elif i % rows == 1:
plus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'up.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'down.png')))
layout.addWidget(plus_button, 0, 1)
layout.addWidget(minus_button, 2, 1)
elif i % rows == 2:
plus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'up.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'down.png')))
layout.addWidget(plus_button, 0, 3)
layout.addWidget(minus_button, 2, 3)
elif arrange_buttons == 'stack':
plus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'right.png')))
minus_button.setIcon(
QtGui.QIcon(os.path.join(path, 'left.png')))
layout.addWidget(minus_button, i % rows, 0 + offset)
layout.addWidget(plus_button, i % rows, 1 + offset)
else:
raise ValueError('Unrecognised arrangment: %s' %
arrange_buttons)
plus_button.setIconSize(icon_size)
plus_button.resize(icon_size)
minus_button.setIconSize(icon_size)
minus_button.resize(icon_size)
def __init__(self,
instrument_dict,
parent=None,
dock_settings_path=None,
scripts_path=None,
working_directory=None): #
"""Args:
instrument_dict(dict) : This is a dictionary containg the
instruments objects where the key is the
objects new name in the generated new Ipython
console
dock_settings_path(str): A path for loading a previous dock widget
configuration
script_path(str): The path of any scripts the user may want to
run using the drop down menu at the top
of the gui
working_directory(str): A path to the requested working directory -
handy if you always wish to save data to
the same directorys
"""
super(GuiGenerator, self).__init__(parent)
self._logger = LOGGER
self.instr_dict = instrument_dict
if working_directory == None:
self.working_directory = os.path.join(os.getcwd())
else:
self.working_directory = working_directory
self.data_file = df.current(working_directory=working_directory)
self.instr_dict['HDF5'] = self.data_file
self.setDockNestingEnabled(1)
uic.loadUi(os.path.join(os.path.dirname(__file__), 'guigenerator.ui'),
self)
self.allDocks = {}
self.allWidgets = {}
self.actions = dict(Views={}, Instruments={})
self.dockwidgetArea = pyqtgraph.dockarea.DockArea()
self.dockWidgetArea = self.replace_widget(self.verticalLayout,
self.centralWidget(),
self.dockwidgetArea)
self.dockWidgetAllInstruments.setWidget(self.dockwidgetArea)
self.dockWidgetAllInstruments.setTitleBarWidget(
QtWidgets.QWidget()) # This trick makes the title bar disappear
# Iterate over all the opened instruments. If the instrument has a GUI (i.e. if they have the get_qt_ui function
# defined inside them), then create a pyqtgraph.Dock for it and add its widget to the Dock. Also prints out any
# instruments that do not have GUIs
self._logger.info('Opening all GUIs')
for instr in self.instr_dict:
self._open_one_gui(instr)
self.terminalWindow = None
self.menuTerminal()
self._addActionViewMenu('Terminal')
self.script_menu = None
if scripts_path is not None:
self.scripts_path = scripts_path
else:
self.scripts_path = 'scripts'
self.makeScriptMenu()
self.NightMode = 1
# address of h5 file
self.filename = df.current().filename
# self._tabifyAll()
self._setupSignals()
if dock_settings_path is not None:
self.dock_settings_path = dock_settings_path
self.menuLoadSettings()
else:
self.dock_settings_path = None
self.showMaximized()
