def test_parameter_hasdefault():
opts = {'name': 'param', 'type': int, 'value': 1}
# default unspecified
p = Parameter(**opts)
assert not p.hasDefault()
p.setDefault(1)
assert p.hasDefault()
assert p.defaultValue() == 1
# default specified
p = Parameter(default=0, **opts)
assert p.hasDefault()
assert p.defaultValue() == 0
def refresh_table(m): #{{{
global params
global parameter
s = "got: " + str(
m.param_count) + "/" + str(m.param_index + 1) + " " + m.param_id
tuner.labelStatusBar.setText(s)
# print m.param_index
gname = m.param_id.split('_')[0]
pname = m.param_id.split('\x00')[0]
ptype = get_param_type(m)
ptmp = {'name': pname, 'type': ptype, 'value': m.param_value}
gindex = get_group_index(params, gname)
if gindex == -1:
params.append({'name': gname, 'type': 'group', 'children': [ptmp]})
else:
pindex = get_param_index(params[gindex]['children'], pname)
if pindex == -1:
params[gindex]['children'].append(ptmp)
else:
if ptype == "int":
params[gindex]['children'][pindex]['type'] = "int"
params[gindex]['children'][pindex]['value'] = int(
round(m.param_value))
else:
params[gindex]['children'][pindex]['value'] = m.param_value
params[gindex]['children'][pindex]['type'] = "float"
if m.param_count == m.param_index + 1:
global parameter, parameter_tree
parameter = Parameter(name='params', type='group', children=params)
parameter_tree.setParameters(parameter, showTop=False)
def __init__(self):
self.headermodel = None
self.selectionmodel = None
self.multiAI = MultiGeometry([])
self.AIs = dict()
widget = ParameterTree()
energy = SimpleParameter(name='Energy',
type='float',
value=10000,
siPrefix=True,
suffix='eV')
wavelength = SimpleParameter(name='Wavelength',
type='float',
value=1.239842e-6 / 10000,
siPrefix=True,
suffix='m')
self.parameter = Parameter(name="Device Profiles",
type='group',
children=[energy, wavelength])
widget.setParameters(self.parameter, showTop=False)
icon = QIcon(str(path('icons/calibrate.png')))
super(DeviceProfiles, self).__init__(icon, "Device Profiles", widget)
self.parameter.sigValueChanged.connect(self.sigRequestRedraw)
self.parameter.sigValueChanged.connect(self.sigRequestReduce)
self.parameter.sigTreeStateChanged.connect(self.simulateCalibrant)
self.parameter.sigTreeStateChanged.connect(self.genAIs)
self.parameter.sigValueChanged.connect(self.simulateCalibrant)
def __init__(self, item):
Exporter.__init__(self, item)
tr = self.getTargetRect()
self.params = Parameter(name='params',
type='group',
children=[
{
'name': 'width',
'type': 'int',
'value': tr.width(),
'limits': (0, None)
},
{
'name': 'height',
'type': 'int',
'value': tr.height(),
'limits': (0, None)
},
{
'name': 'antialias',
'type': 'bool',
'value': True
},
{
'name': 'background',
'type': 'color',
'value': (0, 0, 0, 255)
},
])
self.params.param('width').sigValueChanged.connect(self.widthChanged)
self.params.param('height').sigValueChanged.connect(self.heightChanged)
def __init__(self, name, toolbuttons=None, parameters=None, appendheadertest=None,
centerwidget=None,
bottomwidget=None):
self.name = name
self.centerwidget = centerwidget() if callable(centerwidget) else centerwidget
self.bottomwidget = bottomwidget() if callable(bottomwidget) else bottomwidget
self.rightwidget = ParameterTree()
self.toolbar = QToolBar()
if parameters:
self.parameters = Parameter(name='Params', type='group', children=parameters)
self.rightwidget.setParameters(self.parameters, showTop=False)
if toolbuttons:
for toolbutton in toolbuttons:
self.addToolButton(*toolbutton)
if appendheadertest: self.appendHeader = appendheadertest
self.stages = {'EZPlugin': GUILayout(self.centerwidget, right=self.rightwidget, bottom=self.bottomwidget,
top=self.toolbar)}
super(_EZPlugin, self).__init__()
_EZPlugin.instance = self
def test_init(self):
params_state = {'Name': 'test_params', 'value': None}
test_TCP_Client = TCPClient(params_state=params_state)
assert isinstance(test_TCP_Client, TCPClient)
params_state = Parameter(name='test')
test_TCP_Client = TCPClient(params_state=params_state)
assert isinstance(test_TCP_Client, TCPClient)
def __init__(self, item):
Exporter.__init__(self, item)
tr = self.getTargetRect()
self.params = Parameter(name='params', type='group', children=[
{'name': 'width', 'type': 'float', 'value': tr.width(), 'limits': (0, None)},
{'name': 'height', 'type': 'float', 'value': tr.height(), 'limits': (0, None)},
])
self.params.param('width').sigValueChanged.connect(self.widthChanged)
self.params.param('height').sigValueChanged.connect(self.heightChanged)
def handle_save_file_btn_clicked(self):
saved_file_info = QFileDialog.getSaveFileName(
self,
caption="Save File",
directory=os.path.expanduser('~'),
filter=self.file_format)
saved_file_name = saved_file_info[0]
if saved_file_info[1][1:] not in saved_file_name:
saved_file_name += saved_file_info[1][1:]
if saved_file_name:
if self.export_options_cmb.currentIndex() == 0:
data_exporter = CSVExporter(self.main_display.chart.plotItem)
data_exporter.export(saved_file_name)
elif self.export_options_cmb.currentIndex() == 2:
image_exporter = TimeChartImageExporter(
self.main_display.chart.plotItem)
image_exporter.params = Parameter(
name='params',
type='group',
children=[
{
'name': 'width',
'type': 'int',
'value': self.image_width,
'limits': (0, None)
},
{
'name': 'height',
'type': 'int',
'value': self.image_height,
'limits': (0, None)
},
{
'name': 'antialias',
'type': 'bool',
'value': True
},
{
'name': 'background',
'type': 'color',
'value': self.exported_image_background_color
},
])
image_exporter.widthChanged()
image_exporter.heightChanged()
image_exporter.export(fileName=saved_file_name)
else:
settings_exporter = SettingsExporter(
self.main_display, self.include_pv_chk.isChecked(),
self.include_chart_settings_chk.isChecked())
settings_exporter.export_settings(saved_file_name)
self.close()
QMessageBox.information(self, "Data Export",
"Data exported successfully!")
def selectionChanged(self, selected=None, deselected=None):
if self.selectedIndexes(
) and self.selectedIndexes()[0].row() < self.model().rowCount():
process = self.model().workflow._processes[self.selectedIndexes()
[0].row()]
self.sigShowParameter.emit(process.parameter)
else:
self.sigShowParameter.emit(Parameter(name='empty'))
for child in self.children():
if hasattr(child, 'repaint'): child.repaint()
def __init__(self):
super(PreprocessParameters, self).__init__()
self.parameter = Parameter(name='params', type='group',
children=[{'name': "Preprocess method",
'values': ['Kohler_EMSC','Rubberband'],
'value': 'Kohler_EMSC',
'type': 'list'},
{'name': "Anchor points",
'value': '400, 4000',
'type': 'str'},
{'name': "Fitting regions",
'value': '[(650, 750),(1780, 2680),(3680, 4000)]',
'type': 'str'},
{'name': "Interp method",
'value': 'linear',
'values': ['linear', 'quadratic', 'cubic'],
'type': 'list'}
])
self.setParameters(self.parameter, showTop=False)
self.setIndentation(0)
self.parameter.child('Interp method').hide()
self.parameter.child('Anchor points').hide()
# change Fonts
self.fontSize = 12
font = QFont("Helvetica [Cronyx]", self.fontSize)
boldFont = QFont("Helvetica [Cronyx]", self.fontSize, QFont.Bold)
self.header().setFont(font)
for item in self.listAllItems():
if hasattr(item, 'widget'):
item.setFont(0, boldFont)
item.widget.setFont(font)
item.displayLabel.setFont(font)
item.widget.setMaximumHeight(40)
# init params dict
self.argMap = {"Anchor points": 'anchors',
"Interp method": 'kind',
"Fitting regions": 'w_regions'
}
# set self.processArgs to default value
self.processArgs = {}
for child in self.parameter.childs:
if child.name() == "Anchor points":
self.processArgs['anchors'] = '400, 4000'
elif child.name() == "Interp method":
self.processArgs['kind'] = 'linear'
elif child.name() == "Fitting regions":
self.processArgs['w_regions'] = '[(650, 750), (1780, 2680), (3680, 4000)]'
# connect signals
self.parameter.child('Preprocess method').sigValueChanged.connect(self.updateMethod)
for name in self.argMap.keys():
self.parameter.child(name).sigValueChanged.connect(partial(self.updateParam, name))
def test_parameter_hasdefault():
opts = {"name": "param", "type": int, "value": 1}
# default unspecified
p = Parameter(**opts)
assert p.hasDefault()
assert p.defaultValue() == opts["value"]
p.setDefault(2)
assert p.hasDefault()
assert p.defaultValue() == 2
# default specified
p = Parameter(default=0, **opts)
assert p.hasDefault()
assert p.defaultValue() == 0
# default specified as None
p = Parameter(default=None, **opts)
assert not p.hasDefault()
def update(self, *_):
"""Update the parameter tree according to which algorithm (workflow) is selected."""
# for child in self.param.children(): # this doesn't seem to work...
for child in self.param.childs[1:]:
child.remove()
# Based on current workflow (listParameter value), re-populate the tree.
self.workflow = self._workflows.get(self.listParameter.value().name, self.listParameter.value()())
self._workflows[self.workflow.name] = self.workflow
for operation in self.workflow.operations:
self.param.addChild(Parameter(name=operation.name, type='group', children=operation.as_parameter()))
def test_parameter_hasdefault():
opts = {'name': 'param', 'type': int, 'value': 1}
# default unspecified
p = Parameter(**opts)
assert p.hasDefault()
assert p.defaultValue() == opts["value"]
p.setDefault(2)
assert p.hasDefault()
assert p.defaultValue() == 2
# default specified
p = Parameter(default=0, **opts)
assert p.hasDefault()
assert p.defaultValue() == 0
# default specified as None
p = Parameter(default=None, **opts)
assert not p.hasDefault()
def test_update_lineouts(self, init_prog):
prog = init_prog
ROI_m = mock.Mock()
ROI_m.getRegion.return_value = 1
prog.data_to_export = OrderedDict()
prog.datas = np.linspace(np.linspace(1, 10, 10), np.linspace(11, 20, 10), 2)
ROI_dict = {'ROI_00': ROI_m((0, 0)), 'ROI_01': ROI_m((1, 1)),
'ROI_02': ROI_m((2, 2)), 'ROI_03': ROI_m((3, 3))}
prog.roi_manager.ROIs = ROI_dict
item_param_0 = Parameter(name='ROI_00')
item_param_1 = Parameter(name='ROI_01')
item_param_2 = Parameter(name='ROI_02')
item_param_3 = Parameter(name='ROI_03')
item_params = [item_param_0, item_param_1, item_param_2, item_param_3]
for ind, item_param in enumerate(item_params):
math_param = Parameter(name='math_function')
math_param.setValue('Mean')
channel_param = Parameter(name='use_channel')
channel_param.setValue(1)
L = [0, 1, 2, 3]
channel_param.opts['limits'] = L
color_param = Parameter(name='Color')
color_param.setValue(1)
children = [math_param, channel_param, color_param]
item_param.addChildren(children)
rois_param = Parameter(name='ROIs', children=item_params)
prog.roi_manager.settings = Parameter(name='settings', children=[rois_param])
prog.lo_items = prog.roi_manager.ROIs
prog.update_lineouts()
assert np.array_equal(prog.measurement_dict['datas'], prog.datas)
assert prog.measurement_dict['channels'] == [1, 1, 1, 1]
assert prog.measurement_dict['operations'] == ['Mean', 'Mean', 'Mean', 'Mean']
def __init__(self, item):
Exporter.__init__(self, item)
self.params = Parameter(name='params',
type='group',
children=[
{
'name': 'separator',
'type': 'list',
'value': 'comma',
'values': ['comma', 'tab']
},
])
def __init__(self, item):
Exporter.__init__(self, item)
tr = self.getTargetRect()
if isinstance(item, QtGui.QGraphicsItem):
scene = item.scene()
else:
scene = item
bgbrush = scene.views()[0].backgroundBrush()
bg = bgbrush.color()
if bgbrush.style() == QtCore.Qt.NoBrush:
bg.setAlpha(0)
# Search for DaXView
wid = self.item.getViewWidget()
while wid != None and not isinstance(wid, DaXView.DaXView):
wid = wid.parent()
self.daxview = wid
self.params = Parameter(name='params',
type='group',
children=[
{
'name': 'width',
'type': 'int',
'value': tr.width(),
'limits': (0, None)
},
{
'name': 'height',
'type': 'int',
'value': tr.height(),
'limits': (0, None)
},
{
'name': 'frame rate',
'type': 'int',
'value': 20,
'limits': (1, 60)
},
{
'name': 'antialias',
'type': 'bool',
'value': True
},
{
'name': 'background',
'type': 'color',
'value': bg
},
])
self.params.param('width').sigValueChanged.connect(self.widthChanged)
self.params.param('height').sigValueChanged.connect(self.heightChanged)
def test_parameter_hasdefault_none(passdefault):
# test that Parameter essentially ignores defualt=None, same as not passing
# a default at all
opts = {'name': 'param', 'type': int, 'value': 0}
if passdefault:
opts['default'] = None
p = Parameter(**opts)
assert not p.hasDefault()
assert p.defaultValue() is None
p.setDefault(None)
assert not p.hasDefault()
def __init__(self, item):
Exporter.__init__(self, item)
#tr = self.getTargetRect()
self.params = Parameter(
name='params',
type='group',
children=[
#{'name': 'width', 'type': 'float', 'value': tr.width(), 'limits': (0, None)},
#{'name': 'height', 'type': 'float', 'value': tr.height(), 'limits': (0, None)},
#{'name': 'viewbox clipping', 'type': 'bool', 'value': True},
#{'name': 'normalize coordinates', 'type': 'bool', 'value': True},
#{'name': 'normalize line width', 'type': 'bool', 'value': True},
])
def __init__(self, *args, **kwargs):
super(XPCSProcessor, self).__init__()
self._paramName = 'Algorithm'
self._name = 'XPCS Processor'
self.workflow = None
self.param = None
self._workflows = dict()
self.listParameter = ListParameter(name=self._paramName,
values={'': ''},
value='')
self.param = Parameter(children=[self.listParameter], name=self._name)
self.setParameters(self.param, showTop=False)
def fromParameter(icon, name: str, paramdicts: List[dict]):
if not plugins.qt_is_safe: return None
from pyqtgraph.parametertree import Parameter, ParameterTree
widget = ParameterTree()
parameter = Parameter(name=name, type='group', children=paramdicts)
widget.setParameters(parameter, showTop=False)
def __init__(self):
SettingsPlugin.__init__(self, icon, name, widget)
return type(name + 'SettingsPlugin', (SettingsPlugin, ), {
'__init__': __init__,
'parameter': parameter
})
def selectionChanged(self, selected=None, deselected=None):
if self.selectedIndexes() and self.selectedIndexes()[0].row() < self.model().rowCount():
process = self.model().workflow._processes[self.selectedIndexes()[0].row()]
self.sigShowParameter.emit(process.parameter)
else:
self.sigShowParameter.emit(Parameter(name="empty"))
for child in self.children():
if hasattr(child, "repaint"):
child.repaint()
selectedrows = set(map(lambda index: index.row(), self.selectedIndexes()))
for row in range(self.model().rowCount()):
widget = self.indexWidget(self.model().index(row, 1))
if hasattr(widget, "setSelectedVisibility"):
widget.setSelectedVisibility(row in selectedrows)
self.resizeRowsToContents()
def __init__(self, item):
Exporter.__init__(self, item)
tr = self.getTargetRect()
if isinstance(item, QtGui.QGraphicsItem):
scene = item.scene()
else:
scene = item
bgbrush = scene.views()[0].backgroundBrush()
bg = bgbrush.color()
if bgbrush.style() == QtCore.Qt.NoBrush:
bg.setAlpha(0)
self.params = Parameter(name='params',
type='group',
children=[
{
'name': 'width',
'type': 'int',
'value': tr.width(),
'limits': (0, None)
},
{
'name': 'height',
'type': 'int',
'value': tr.height(),
'limits': (0, None)
},
{
'name': 'antialias',
'type': 'bool',
'value': True
},
{
'name': 'background',
'type': 'color',
'value': bg
},
])
self.params.param('width').sigValueChanged.connect(self.widthChanged)
self.params.param('height').sigValueChanged.connect(self.heightChanged)
def __init__(self, item):
Exporter.__init__(self, item)
self.params = Parameter(name='params',
type='group',
children=[
{
'name': 'separator',
'type': 'list',
'value': 'comma',
'values': ['comma', 'tab']
},
{
'name': 'precision',
'type': 'int',
'value': 10,
'limits': [0, None]
},
])
def __init__(self, item):
Exporter.__init__(self, item)
# Exporter config options
self.params = Parameter(name='params',
type='group',
children=[
{
'name': 'Data Type',
'type': 'list',
'value': 'int',
'values': {
'Default [Preserve Raw Type]':
None,
'float': np.float,
'int': np.int,
}
},
])
def __init__(self, item):
Exporter.__init__(self, item)
tr = self.getTargetRect()
if isinstance(item, QtGui.QGraphicsItem):
scene = item.scene()
else:
scene = item
# scene.views()[0].backgroundBrush()
bgbrush = pg.mkBrush("w")
bg = bgbrush.color()
if bgbrush.style() == QtCore.Qt.NoBrush:
bg.setAlpha(0)
self.params = Parameter(
name="params",
type="group",
children=[
{
"name": "width",
"type": "int",
"value": tr.width(),
"limits": (0, None),
},
{
"name": "height",
"type": "int",
"value": tr.height(),
"limits": (0, None),
},
{
"name": "antialias",
"type": "bool",
"value": True
},
{
"name": "background",
"type": "color",
"value": bg
},
],
)
self.params.param("width").sigValueChanged.connect(self.widthChanged)
self.params.param("height").sigValueChanged.connect(self.heightChanged)
def __init__(self,name='TestPlugin',toolbuttons=[],parameters=[],openfileshandler=None,centerwidget=pg.ImageView,
bottomwidget=pg.PlotWidget,panels=[]):
self.name=name
self.parameters = Parameter(name='Params',type='group',children=parameters)
self.centerwidget=centerwidget() if callable(centerwidget) else centerwidget
self.bottomwidget=bottomwidget() if callable(bottomwidget) else bottomwidget
self.rightwidget=ParameterTree()
self.toolbar=QtGui.QToolBar()
self.rightwidget.setParameters(self.parameters,showTop=False)
for toolbutton in toolbuttons:
self.addToolButton(*toolbutton)
if openfileshandler: self.openfiles=openfileshandler
self.rightmodes = panels
super(EZplugin, self).__init__([])
def __init__(self, parent=None, showHeader=True, processor: Callable[[], None] = None):
"""Create the parameter tree, optionally providing a workflow.
When a workflow is provided,
Parameters
----------
parent
See pyqtgraph.ParameterTree.__init__.
showHeader
See pyqtgraph.ParameterTree.__init__.
processor
If provided, creates a 'Run' button that is connected to the callable passed (default is None).
For example, this callable could grab the necessary data to pass into a workflow, then execute it.
"""
super(CorrelationParameterTree, self).__init__(parent, showHeader)
self._paramName = 'Algorithm'
self._name = 'Correlation Processor'
self.processor = processor
self.param = None
self.workflow = None
self._workflows = dict()
# List of algorithms available
# key -> algorithm name (workflow.name)
# value -> algorithm callable (workflow)
self.listParameter = ListParameter(name=self._paramName,
values={'':''},
value='')
self.param = Parameter(name=self._name)
self.param.addChild(self.listParameter)
self.setParameters(self.param, showTop=False)
if self.processor:
# Button added separately since update removes then adds all children in self.param
self.processButton = ActionParameter(name="Run")
self.processButton.sigActivated.connect(self.processor)
self.addParameters(self.processButton)
def __init__(self,
header: NonDBHeader = None,
stream: str = 'primary',
field: str = 'primary'):
"""
A widget to display imageCube like dataset with ROI buttons
:param header: Xi-cam datahandler header
:param field: header's field param
"""
super(MapView, self).__init__()
# layout set up
self.setOrientation(Qt.Vertical)
self.imageview = MapViewWidget()
self.spectra = SpectraPlotWidget()
self.spectraSplitter = QSplitter()
self.spectraSplitter.addWidget(self.spectra)
# self.spectraSplitter.insertWidget(1, BetterButtons()) # add a 2D spectrum window
# self.spectra.getViewBox().setXRange(0, 4000) # set xrange
self.imageview_and_toolbar = QSplitter()
self.imageview_and_toolbar.setOrientation(Qt.Horizontal)
self.toolbar_and_param = QSplitter()
self.toolbar_and_param.setOrientation(Qt.Vertical)
#define tool bar
self.toolBar = QWidget()
self.gridlayout = QGridLayout()
self.toolBar.setLayout(self.gridlayout)
#add tool bar buttons
self.roiBtn = QToolButton()
self.roiBtn.setText('Manual ROI')
self.roiBtn.setCheckable(True)
self.roiMeanBtn = QToolButton()
self.roiMeanBtn.setText('ROI Mean')
self.autoMaskBtn = QToolButton()
self.autoMaskBtn.setText('Auto ROI')
self.autoMaskBtn.setCheckable(True)
self.selectMaskBtn = QToolButton()
self.selectMaskBtn.setText('Mark Select')
self.selectMaskBtn.setCheckable(True)
self.saveRoiBtn = QToolButton()
self.saveRoiBtn.setText('Save ROI')
self.saveRoiBtn.setCheckable(False)
self.loadRoiBtn = QToolButton()
self.loadRoiBtn.setText('Load ROI')
self.loadRoiBtn.setCheckable(False)
self.gridlayout.addWidget(self.roiBtn, 0, 0, 1, 1)
self.gridlayout.addWidget(self.autoMaskBtn, 0, 1, 1, 1)
self.gridlayout.addWidget(self.selectMaskBtn, 1, 0, 1, 1)
self.gridlayout.addWidget(self.roiMeanBtn, 1, 1, 1, 1)
self.gridlayout.addWidget(self.saveRoiBtn, 2, 0, 1, 1)
self.gridlayout.addWidget(self.loadRoiBtn, 2, 1, 1, 1)
self.parameterTree = ParameterTree()
self.parameter = Parameter(name='Threshhold',
type='group',
children=[
{
'name': 'Amide II',
'value': 0,
'type': 'float'
},
{
'name': "ROI type",
'values': ['+', '-'],
'value': '+',
'type': 'list'
},
])
self.parameter.child('Amide II').setOpts(step=0.1)
self.parameterTree.setParameters(self.parameter, showTop=False)
self.parameterTree.setHeaderLabels(['Params', 'Value'])
self.parameterTree.setIndentation(0)
# Assemble widgets
self.toolbar_and_param.addWidget(self.toolBar)
self.toolbar_and_param.addWidget(self.parameterTree)
self.toolbar_and_param.setSizes([1000,
1]) #adjust initial splitter size
self.imageview_and_toolbar.addWidget(self.toolbar_and_param)
self.imageview_and_toolbar.addWidget(self.imageview)
self.imageview_and_toolbar.setSizes([1, 1000
]) #adjust initial splitter size
self.addWidget(self.imageview_and_toolbar)
self.addWidget(self.spectraSplitter)
self.setSizes([1000, 1000]) # adjust initial splitter size
# readin header
self.imageview.setHeader(header, field='image')
self.spectra.setHeader(header, field='spectra')
self.header = header
#setup ROI item
sideLen = 10
self.roi = pg.PolyLineROI(positions=[[0, 0], [sideLen, 0],
[sideLen, sideLen], [0, sideLen]],
closed=True)
self.imageview.view.addItem(self.roi)
self.roiInitState = self.roi.getState()
self.roi.hide()
#constants
self.path = os.path.expanduser('~/')
self.pixSelection = {
'ROI': None,
'Mask': None
} # init pixel selection dict
# Connect signals
self.imageview.sigShowSpectra.connect(self.spectra.showSpectra)
self.spectra.sigEnergyChanged.connect(self.imageview.setEnergy)
self.roiBtn.clicked.connect(self.roiBtnClicked)
self.roi.sigRegionChangeFinished.connect(self.roiSelectPixel)
self.roi.sigRegionChangeFinished.connect(self.showSelectMask)
self.sigRoiPixels.connect(self.spectra.getSelectedPixels)
self.roiMeanBtn.clicked.connect(self.spectra.showMeanSpectra)
self.autoMaskBtn.clicked.connect(self.showAutoMask)
self.selectMaskBtn.clicked.connect(self.showSelectMask)
self.saveRoiBtn.clicked.connect(self.saveRoi)
self.loadRoiBtn.clicked.connect(self.loadRoi)
self.parameter.child('Amide II').sigValueChanged.connect(
self.showAutoMask)
self.parameter.child('Amide II').sigValueChanged.connect(
self.intersectSelection)
self.parameter.child('ROI type').sigValueChanged.connect(
self.intersectSelection)
return LAST_VALUE
#}}}
qt_mav = QtMav(outdevice, indevice)
# create gui
app = QtGui.QApplication(sys.argv)
f = open("tuner_ui.py.tmp", "w")
uic.compileUi("tuner.ui", f)
tuner = uic.loadUi("tuner.ui")
params = []
parameter = Parameter(name='params', type='group', children=params)
parameter_tree = ParameterTree(parent=tuner.tabTime)
parameter_tree.setParameters(parameter, showTop=False)
parameter_tree.resize(300, 500)
def get_group_index(params, gname): #{{{
"""
recursive group refreshing/adding
params -- parameters structure
gname -- string representing name
return:
index in params structure
-1 if not found
"""
i = 0
def addParameter(self, **kwargs):
self.rightwidget.addParameters(Parameter(**kwargs))
