def onCalibrationChanged(self, calibration):
calibration = str(calibration)
if self.myCalibration:
self.settings.parameters[self.settings.calibration] = self.myCalibration.parameters
self.myCalibration = AnalogInputCalibration.AnalogInputCalibrationMap[calibration]()
if calibration in self.settings.parameters:
self.myCalibration.parameters = self.settings.parameters[calibration]
if not self.treeWidget:
try:
self.param = Parameter.create(name='params', type='group', children=self.myCalibration.paramDef())
self.treeWidget = ParameterTree()
self.treeWidget.setParameters(self.param, showTop=False)
self.verticalLayout.insertWidget(2, self.treeWidget)
self.param.sigTreeStateChanged.connect(self.myCalibration.update, QtCore.Qt.UniqueConnection)
except (TypeError, AttributeError):
pass
else:
self.param = Parameter.create(name='params', type='group', children=self.myCalibration.paramDef())
self.treeWidget.setParameters(self.param, showTop=False)
try:
self.param.sigTreeStateChanged.connect(self.myCalibration.update, QtCore.Qt.UniqueConnection )
except TypeError:
pass # we want the connection to be unique
self.settings.calibration = calibration
self.callback( self.channel, self.myCalibration )
def __init__(self, **opts):
opts['type'] = 'bool'
opts['value'] = True
Parameter.__init__(self, **opts)
self.addChild({'name': 'A = 1/B', 'type': 'float', 'value': 7, 'suffix': 'Hz', 'siPrefix': True})
self.addChild({'name': 'B = 1/A', 'type': 'float', 'value': 1/7., 'suffix': 's', 'siPrefix': True})
self.a = self.param('A = 1/B')
self.b = self.param('B = 1/A')
self.a.sigValueChanged.connect(self.aChanged)
self.b.sigValueChanged.connect(self.bChanged)
class ImageExporter(Exporter):
Name = "Image File (PNG, TIF, JPG, ...)"
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 widthChanged(self):
sr = self.getSourceRect()
ar = sr.height() / sr.width()
self.params.param('height').setValue(self.params['width'] * ar, blockSignal=self.heightChanged)
def heightChanged(self):
sr = self.getSourceRect()
ar = sr.width() / sr.height()
self.params.param('width').setValue(self.params['height'] * ar, blockSignal=self.widthChanged)
def parameters(self):
return self.params
def export(self, fileName=None):
if fileName is None:
filter = ["*."+str(f) for f in QtGui.QImageWriter.supportedImageFormats()]
preferred = ['*.png', '*.tif', '*.jpg']
for p in preferred[::-1]:
if p in filter:
filter.remove(p)
filter.insert(0, p)
self.fileSaveDialog(filter=filter)
return
targetRect = QtCore.QRect(0, 0, self.params['width'], self.params['height'])
sourceRect = self.getSourceRect()
#self.png = QtGui.QImage(targetRect.size(), QtGui.QImage.Format_ARGB32)
#self.png.fill(pyqtgraph.mkColor(self.params['background']))
bg = np.empty((self.params['width'], self.params['height'], 4), dtype=np.ubyte)
color = self.params['background']
bg[:,:,0] = color.blue()
bg[:,:,1] = color.green()
bg[:,:,2] = color.red()
bg[:,:,3] = color.alpha()
self.png = pg.makeQImage(bg, alpha=True)
painter = QtGui.QPainter(self.png)
try:
self.setExportMode(True, {'antialias': self.params['antialias'], 'background': self.params['background']})
self.getScene().render(painter, QtCore.QRectF(targetRect), sourceRect)
finally:
self.setExportMode(False)
self.png.save(fileName)
painter.end()
class SVGExporter(Exporter):
Name = "Scalable Vector Graphics (SVG)"
allowCopy = True
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},
])
#self.params.param('width').sigValueChanged.connect(self.widthChanged)
#self.params.param('height').sigValueChanged.connect(self.heightChanged)
def widthChanged(self):
sr = self.getSourceRect()
ar = sr.height() / sr.width()
self.params.param('height').setValue(self.params['width'] * ar, blockSignal=self.heightChanged)
def heightChanged(self):
sr = self.getSourceRect()
ar = sr.width() / sr.height()
self.params.param('width').setValue(self.params['height'] * ar, blockSignal=self.widthChanged)
def parameters(self):
return self.params
def export(self, fileName=None, toBytes=False, copy=False):
if toBytes is False and copy is False and fileName is None:
self.fileSaveDialog(filter="Scalable Vector Graphics (*.svg)")
return
## Qt's SVG generator is not complete. (notably, it lacks clipping)
## Instead, we will use Qt to generate SVG for each item independently,
## then manually reconstruct the entire document.
xml = generateSvg(self.item)
if toBytes:
return xml.encode('UTF-8')
elif copy:
md = QtCore.QMimeData()
md.setData('image/svg+xml', QtCore.QByteArray(xml.encode('UTF-8')))
QtGui.QApplication.clipboard().setMimeData(md)
else:
with open(fileName, 'wb') as fh:
fh.write(asUnicode(xml).encode('utf-8'))
def setupParameters(self):
ssParams = [{'name':'connection', 'type':'list', 'key':'con', 'values':{"System Serial Port":SimpleSerial_serial(showScriptParameter=self.showScriptParameter),
"ChipWhisperer":SimpleSerial_ChipWhisperer(showScriptParameter=self.showScriptParameter),
"ChipWhisperer-Lite":SimpleSerial_ChipWhispererLite(showScriptParameter=self.showScriptParameter)},
'value':"System Serial Port", 'set':self.setConnection},
{'name':'Key Length', 'type':'list', 'values':[128, 256], 'value':128, 'set':self.setKeyLen},
# {'name':'Plaintext Command', 'key':'ptcmd', 'type':'list', 'values':['p', 'h'], 'value':'p'},
{'name':'Init Command', 'key':'cmdinit', 'type':'str', 'value':''},
{'name':'Load Key Command', 'key':'cmdkey', 'type':'str', 'value':'k$KEY$\\n'},
{'name':'Load Input Command', 'key':'cmdinput', 'type':'str', 'value':''},
{'name':'Go Command','key':'cmdgo', 'type':'str', 'value':'p$TEXT$\\n'},
{'name':'Output Format', 'key':'cmdout', 'type':'str', 'value':'r$RESPONSE$\\n'},
#{'name':'Data Format', 'key':'datafmt', 'type':'list', 'values':{'DEADBEEF':'',
# 'DE AD BE EF':' ',
# 'DE:AD:BE:EF':':',
# 'DE-AD-BE-EF':'-'}, 'value':''},
]
self.params = Parameter.create(name='Target Connection', type='group', children=ssParams)
ExtendedParameter.setupExtended(self.params, self)
self.ser = None
self.keylength = 16
self.input = ""
self.oa = None
self.setConnection(self.findParam('con').value())
def setupParameters(self):
ssParams = [{'name':'baud', 'type':'int', 'key':'baud', 'value':38400, 'limits':(500, 2000000), 'get':self.baud, 'set':self.setBaud}]
self.params = Parameter.create(name='Serial Port Settings', type='group', children=ssParams)
ExtendedParameter.setupExtended(self.params, self)
self.cwlite_usart = None
self.oa = None
def __init__(self, dictFiltPara=None):
self.dictFiltPara = dictFiltPara
self.bandDict = {"bandpass": 0, "lowpass": 1, "highpass": 2}
self.filtDict = {'name': 'Filter', 'type': 'group', 'children': [
{'name': 'band', 'type': 'list', 'values': self.bandDict, 'value': 0},
{'name': 'order', 'type': 'int', 'value': 2},
{'name': 'lowFreq', 'type': 'float', 'value': 0.02, 'step': 0.1, 'suffix': ' Hz'},
{'name': 'highFreq', 'type': 'float', 'value': 2.0, 'step': 0.1, 'suffix': ' Hz'},
{'name': 'reversepass', 'type': 'bool', 'value': False, 'tip': "This is a checkbox"},
{'name': 'seis', 'type': 'list', 'values': {"Stack": 0, "Trace": 1}, 'value': 0},
{'name': 'apply', 'type': 'bool', 'value': False, 'tip': "This is a checkbox"},
{'name': 'Confirm_Filt_Parameters', 'type': 'action'},
]}
self.filtKeys = ['lowFreq', 'highFreq', 'order', 'apply', 'reversepass']
self.params = [
RadioParameter(name='Sort'),
self.filtDict,
]
## Create tree of Parameter objects
self.paraTree = Parameter.create(name='params', type='group', children=self.params)
self.paraTree.sigTreeStateChanged.connect(self.treeChanged)
self.paraSort = self.paraTree.children()[0]
self.paraFilt = self.paraTree.children()[1]
self.onStack = True
# get parameters for action:
self.getSortPara()
self.setFiltTree()
self.getFiltPara()
def __init__(self, showScriptParameter=None, CWMainWindow=None):
self.cwAdv = CWAdvTrigger()
paramSS = [
{'name':'Serial Settings', 'type':'group', 'children':[
{'name':'Baud', 'key':'baud', 'type':'int', 'limits':(100, 500000), 'value':38400, 'step':100, 'set':self.updateSampleRate},
{'name':'Start Bits', 'key':'startbits', 'type':'int', 'limits':(1, 10), 'value':1},
{'name':'Stop Bits', 'key':'stopbits', 'type':'int', 'limits':(1, 10), 'value':1},
{'name':'Parity', 'key':'parity', 'type':'list', 'values':['none', 'even'], 'value':'none'},
]},
# TODO: Need to confirm oversample rate stuff
{'name':'Oversample Rate', 'key':'osrate', 'type':'int', 'limits':(2, 5), 'value':3, 'set':self.updateSampleRate},
{'name':'Calculated Clkdiv', 'key':'calcclkdiv', 'type':'int', 'readonly':True},
{'name':'Calculated Error', 'key':'calcerror', 'type':'int', 'suffix':'%', 'readonly':True},
{'name':'Trigger Character', 'key':'trigpatt', 'type':'str', 'value':'""', 'set':self.setPattern},
{'name':'Binary Pattern', 'key':'binarypatt', 'type':'str', 'value':''},
{'name':'Reset Module', 'type':'action', 'action':self.reset},
{'name':'Advanced Settings', 'type':'group', 'children':[
{'name':'Threshold', 'key':'threshold', 'type':'int', 'value':1, 'limits':(1, 10), 'set':self.reset},
{'name':'Initial Bit Correction', 'key':'initialcorrect', 'type':'int', 'value':3, 'limits':(0, 10), 'set':self.reset},
]}
]
self.oa = None
self.params = Parameter.create(name='Digital Pattern Trigger Module', type='group', children=paramSS)
ExtendedParameter.setupExtended(self.params, self)
self.showScriptParameter = showScriptParameter
def __init__(self, subkeys=16, permPerSubkey=256):
super(ResultsPlotData, self).__init__()
self.numKeys = subkeys
self.numPerms = permPerSubkey
self._knownkey = None
self.enabledbytes = [False] * subkeys
self.doRedraw = True
self.orfunction = None
self.byteNumAct = []
for i in range(0, self.numKeys):
self.byteNumAct.append(QAction("%d" % i, self))
self.byteNumAct[i].triggered[bool].connect(partial(self.setBytePlot, i))
self.byteNumAct[i].setCheckable(True)
byteNumAllOn = QAction("All On", self)
byteNumAllOff = QAction("All Off", self)
byteNumAllOn.triggered.connect(partial(self.setByteAll, False))
byteNumAllOff.triggered.connect(partial(self.setByteAll, True))
self.bselection = QToolBar()
for i in range(0, self.numKeys):
self.bselection.addAction(self.byteNumAct[i])
self.bselection.addAction(byteNumAllOn)
self.bselection.addAction(byteNumAllOff)
self.layout().addWidget(self.bselection)
self.highlightTop = True
resultsParams = self.genericParameters()
self.params = Parameter.create(name=self.name, type="group", children=resultsParams)
ExtendedParameter.setupExtended(self.params, self)
def _draw_text_inputs(self, layout):
"""
Generates a GUI that can accept parameter values.
"""
params = [
{'name': 'damage :: Saturation Threshold', 'type': 'int',
'value': 10000, 'suffix': 'ADU'},
{'name': 'damage :: Area Threshold', 'type': 'int',
'value': 20, 'suffix': '%', 'limits': (0, 100)},
{'name': 'xtal :: Saturation Threshold', 'type': 'int',
'value': 5000, 'suffix': 'ADU'},
{'name': 'xtal :: Area Threshold', 'type': 'int',
'value': 1, 'suffix': '%', 'limits': (0, 100)},
{'name': 'diffuse :: Saturation Threshold', 'type': 'int',
'value': 1000, 'suffix': 'ADU'},
{'name': 'diffuse :: Area Threshold', 'type': 'int',
'value': 20, 'suffix': '%', 'limits': (0, 100)}
]
self._params = Parameter.create(name='params', type='group',
children=params)
self._params.sigTreeStateChanged.connect(self._enable_apply)
t = ParameterTree()
t.setParameters(self._params, showTop=False)
layout.addWidget(t, 0, 1)
return
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.basicParam = {'name': 'Layer','expanded':False, 'type': 'group','autoIncrementName':True, 'children': [
{'name': 'LayerType', 'type': 'list', 'values': {"RGB": 0, "LAB": 1, "ChannelWise": 2}, 'value': 0},
{'name': 'Channel', 'type': 'int', 'value': 0,'limits':[0,2]},
{'name': 'Opacity', 'type': 'float', 'value': 0.0, 'step': 0.1,'limits':[0,1]},
{'name': 'Show', 'type': 'bool', 'value': True, 'tip': "Show / Hide this layer"},
{'name': 'HideOthers', 'type': 'action','tip':"Hide all other layers"},
{'name': 'Gradient', 'type': 'colormap'},
#{'name': 'Subgroup', 'type': 'group', 'children': [
# {'name': 'Sub-param 1', 'type': 'int', 'value': 10},
# {'name': 'Sub-param 2', 'type': 'float', 'value': 1.2e6},
#]},
#{'name': 'Text Parameter', 'type': 'text', 'value': 'Some text...'},
#{'name': 'Action Parameter', 'type': 'action'},
]}
params = []
self.paramGroup = Parameter.create(name='params', type='group', children=params)
self.paramGroup.sigTreeStateChanged.connect(self.change)
self.parameterTree = ParameterTree()
self.parameterTree.setParameters(self.paramGroup, showTop=False)
# add view box to graph view layout
self.hbox = QtGui.QHBoxLayout()
self.setLayout(self.hbox)
self.hbox.addWidget(self.parameterTree)
def __init__(self):
QtGui.QWidget.__init__(self)
self.neuron_data = None
self.setWindowTitle("Experiment Control - Data Analysis & Visualization")
self.layout = QtGui.QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
self.splitter = QtGui.QSplitter()
self.splitter.setOrientation(QtCore.Qt.Horizontal)
self.splitter2 = QtGui.QSplitter()
self.splitter2.setOrientation(QtCore.Qt.Vertical)
self.layout.addWidget(self.splitter)
self.splitter.addWidget(self.splitter2)
self.plot_widget = pg.GraphicsLayoutWidget()
self.tree = ParameterTree(showHeader=False)
self.params = Parameter.create(
name="params",
type="group",
children=[
dict(name="Reanalyze", type="bool", value=False),
dict(name="Load", type="action"),
dict(name="GCFR-sigma (ms)", type="float", value=100.0, step=0.1, limits=[1, 5000]),
dict(name="Save", type="action"),
],
)
self.tree.setParameters(self.params, showTop=False)
# self.params.param('Save').sigActivated.connect(self.SavePlot)
self.params.param("Load").sigActivated.connect(self.OpenDataFile)
self.splitter2.addWidget(self.tree)
self.trial_list_tree = pg.TreeWidget(parent=self.splitter2)
self.splitter.addWidget(self.plot_widget)
self.trial_list_tree.setColumnCount(1)
def __init__(self, parameterView):
"""Constructor. Defines all default parameters."""
super(ParameterTreeWidget, self).__init__()
defaultParams = [
{'name': 'General', 'type': 'group', 'children': [
{'name': 'General Config File Path',
'type': 'str', 'value': "config.cfg"},
]},
{'name': 'Video', 'type': 'group', 'children': [
{'name': 'GStreamer Video Source', 'type': 'list', 'values': {"Test Source": "videotestsrc", "Webcam": "v4l2src", "network": "udp"}, 'value': "videotestsrc", 'children': [
{'name': 'Network Source IP',
'type': 'str', 'value': "127.0.0.1"},
]},
{'name': 'Video Frame Rate', 'type': 'float',
'value': 5e1, 'siPrefix': True, 'suffix': 'Hz'},
{'name': 'Video Output File', 'type': 'str', 'value': "outvideo.mp4"},
{'name': 'Video Output File Policy', 'type': 'list', 'values': {
"Overwrite": "overwrite", "Append": "append", "Enumerate": "enumerate"}, 'value': "overwrite"},
]},
{'name': 'Annotation', 'type': 'group', 'children': [
{'name': 'Data Sample Rate', 'type': 'float',
'value': 5e1, 'siPrefix': True, 'suffix': 'Hz'},
{'name': 'Concurrent Labels', 'type': 'bool', 'value': False},
{'name': 'Save Annotator Key Mapping',
'type': 'bool', 'value': True},
{'name': 'Annotator Key Mapping Save File',
'type': 'str', 'value': "keymap.cfg"},
{'name': 'Annotator Data Output Target', 'type': 'list', 'values': {
"File": "file", "Standard Output": "stdout"}, 'value': "file"},
{'name': 'Data Output Filename', 'type': 'str',
'value': "annotated_data.txt"},
]},
{'name': 'Plotting', 'type': 'group', 'children': [
{'name': 'Plotted Samples', 'type': 'int', 'value': 500},
{'name': 'Plotter Refresh Rate', 'type': 'float',
'value': 2e1, 'siPrefix': True, 'suffix': 'Hz'},
]},
]
# MORE PARAMS TO BE IMPLEMENTED
# - output video file path
# - overwrite / append / create new output video file
# - custom Gstreamer source string
self.p = Parameter.create(
name='params', type='group', children=defaultParams)
"""
def flatten(param):
items = []
for ch in param.children():
items.extend(flatten(ch).items())
items.extend({param.name() : param.value()}.items())
return dict(items)
"""
self.t = parameterView # use the ID of the promoted graphicsView
self.t.setParameters(self.p, showTop=False)
self.t.show()
def get_gop_index( index ):
global allframeinfo,gopinfo,coded_video_frames
frame_number = int( framerlog.currentItem().statusTip() )
params = [{'name': 'Frame Information', 'type': 'group', 'children': []}]
params[0]['children'].append({'name': "key_frame", 'type': 'str', 'value':coded_video_frames[frame_number].key_frame, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pkt_pts", 'type': 'str', 'value':coded_video_frames[frame_number].pkt_pts, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pkt_pts_time", 'type': 'str', 'value':coded_video_frames[frame_number].pkt_pts_time, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pkt_dts", 'type': 'str', 'value':coded_video_frames[frame_number].pkt_dts, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pkt_dts_time", 'type': 'str', 'value':coded_video_frames[frame_number].pkt_dts_time, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "best_effort_timestamp", 'type': 'str', 'value':coded_video_frames[frame_number].best_effort_timestamp, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "best_effort_timestamp_time", 'type': 'str', 'value':coded_video_frames[frame_number].best_effort_timestamp_time, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pkt_duration", 'type': 'str', 'value':coded_video_frames[frame_number].pkt_duration, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pkt_duration_time", 'type': 'str', 'value':coded_video_frames[frame_number].pkt_duration_time, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pkt_pos", 'type': 'str', 'value':coded_video_frames[frame_number].pkt_pos, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pkt_size", 'type': 'str', 'value':coded_video_frames[frame_number].pkt_size, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "width", 'type': 'str', 'value':coded_video_frames[frame_number].width, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "height", 'type': 'str', 'value':coded_video_frames[frame_number].height, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pix_fmt", 'type': 'str', 'value':coded_video_frames[frame_number].pix_fmt, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "sample_aspect_ratio", 'type': 'str', 'value':coded_video_frames[frame_number].sample_aspect_ratio, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "pict_type", 'type': 'str', 'value':coded_video_frames[frame_number].pict_type, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "coded_picture_number", 'type': 'str', 'value':coded_video_frames[frame_number].coded_picture_number, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "display_picture_number", 'type': 'str', 'value':coded_video_frames[frame_number].display_picture_number, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "interlaced_frame", 'type': 'str', 'value':coded_video_frames[frame_number].interlaced_frame, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "top_field_first", 'type': 'str', 'value':coded_video_frames[frame_number].top_field_first, 'siPrefix': False, 'suffix': '', 'readonly': True})
params[0]['children'].append({'name': "repeat_pict", 'type': 'str', 'value':coded_video_frames[frame_number].repeat_pict, 'siPrefix': False, 'suffix': '', 'readonly': True})
fp = Parameter.create(name='params', type='group', children=params)
gopinfo.setParameters(fp, showTop=False)
def __init__(self,console=None,showScriptParameter=None):
super(VisaScope, self).__init__()
self.showScriptParameter = showScriptParameter
self.console = console
self.visaInst = None
scopeParams = [
{'name':'X-Scale', 'key':'xscale', 'type':'list', 'values':self.xScales},
{'name':'Y-Scale', 'key':'yscale', 'type':'list', 'values':self.yScales},
{'name':'Y-Offset', 'key':'yoffset', 'type':'float', 'step':1E-3, 'siPrefix': True, 'suffix': 'V'},
{'name':'X-Offset', 'key':'xoffset', 'type':'float', 'step':1E-6, 'siPrefix': True, 'suffix': 'S'},
{'name':'Download Offset', 'key':'xdisporigin', 'type':'int', 'limits':(0,1E9)},
{'name':'Download Size', 'key':'xdisprange', 'type':'int', 'limits':(0,1E9)},
]
for t in self.getAdditionalParams():
scopeParams.append(t)
self.params = Parameter.create(name='Scope Settings', type='group', children=scopeParams)
ExtendedParameter.setupExtended(self.params, self)
def setupParameters(self):
cpaalgos = {'Progressive':CPAProgressive,
'Simple':CPASimpleLoop}
#if CPACython is not None:
# cpaalgos['Progressive-Cython'] = CPACython.AttackCPA_Progressive
attackParams = [{'name':'CPA Algorithm', 'key':'CPA_algo', 'type':'list', 'values':cpaalgos, 'value':CPAProgressive, 'set':self.updateAlgorithm},
{'name':'Hardware Model', 'type':'group', 'children':[
{'name':'Crypto Algorithm', 'key':'hw_algo', 'type':'list', 'values':{'AES-128 (8-bit)':models_AES128_8bit, 'AES-256 (8-bit)':models_AES256_8bit}, 'value':'AES-128', 'set':self.updateScript},
{'name':'Key Round', 'key':'hw_round', 'type':'list', 'values':{'first':0, 'last':-1}, 'value':0, 'set':self.updateScript},
{'name':'Power Model', 'key':'hw_pwrmodel', 'type':'list', 'values':{'Hamming Weight':'HypHW', 'Hamming Distance':'HypHD'}, 'value':'Hamming Weight', 'set':self.updateScript},
{'name':'Direction', 'key':'aes_dir', 'type':'list', 'values':{'Encryption (PT=Input)':'enc', 'Decryption (PT=Input)':'dec'}, 'value':'enc', 'set':self.updateScript},
]},
#TODO: Should be called from the AES module to figure out # of bytes
{'name':'Attacked Bytes', 'type':'group', 'children':
self.getByteList()
},
]
self.params = Parameter.create(name='Attack', type='group', children=attackParams)
ExtendedParameter.setupExtended(self.params, self)
self.setAnalysisAlgorithm(CPAProgressive, None, None)
self.updateBytesVisible()
self.updateScript()
def setupParameters(self):
"""Setup parameters specific to preprocessing module"""
ssParams = [{'name':'Enabled', 'type':'bool', 'value':True, 'set':self.setEnabled},
# PUT YOUR PARAMETERS HERE
{'name':'Desc', 'type':'text', 'value':self.descrString}]
self.params = Parameter.create(name='Name of Module', type='group', children=ssParams)
ExtendedParameter.setupExtended(self.params, self)
def setupParameters(self):
ssParams = [{'name':'Interface', 'type':'list', 'key':'target', 'values':['xmega (PDI)', 'avr (ISP)'], 'value':'xmega (PDI)'},
{'name':'Post-Reset Delay', 'type':'int', 'key':'toggledelay', 'limits':(0, 10E3), 'value':0, 'suffix':'mS'},
{'name':'Test Reset', 'type':'action', 'action':self.testReset}
]
self.params = Parameter.create(name='Reset AVR/XMEGA via CW-Lite', type='group', children=ssParams)
ExtendedParameter.setupExtended(self.params, self)
def __init__(self, subkeys=16, permPerSubkey=256):
super(ResultsPlotData, self).__init__()
self.numKeys = subkeys
self.numPerms = permPerSubkey
self._knownkey = None
self.enabledbytes = [False]*subkeys
self.doRedraw = True
self.orfunction = None
self.byteNumAct = []
for i in range(0,self.numKeys):
self.byteNumAct.append(QAction('%d'%i, self))
self.byteNumAct[i].triggered[bool].connect(partial(self.setBytePlot, i))
self.byteNumAct[i].setCheckable(True)
byteNumAllOn = QAction('All On', self)
byteNumAllOff = QAction('All Off', self)
byteNumAllOn.triggered.connect(partial(self.setByteAll, False))
byteNumAllOff.triggered.connect(partial(self.setByteAll, True))
self.bselection = QToolBar()
for i in range(0, self.numKeys):
self.bselection.addAction(self.byteNumAct[i])
self.bselection.addAction(byteNumAllOn)
self.bselection.addAction(byteNumAllOff)
self.layout().addWidget(self.bselection)
self.highlightTop = True
resultsParams = [{'name':'Show', 'type':'bool', 'key':'show', 'value':False, 'set':self.showDockSignal.emit},
]
self.params = Parameter.create(name=self.name, type='group', children=resultsParams)
ExtendedParameter.setupExtended(self.params, self)
def setupParameters(self):
cpaalgos = {'Progressive':CPAProgressive,
'Simple':CPASimpleLoop}
#if CPACython is not None:
# cpaalgos['Progressive-Cython'] = CPACython.AttackCPA_Progressive
if CPAProgressive_CAccel is not None:
cpaalgos['Progressive-C Accel'] = CPAProgressive_CAccel
attackParams = [{'name':'CPA Algorithm', 'key':'CPA_algo', 'type':'list', 'values':cpaalgos, 'value':CPAProgressive, 'set':self.updateAlgorithm},
{'name':'Hardware Model', 'type':'group', 'children':[
{'name':'Crypto Algorithm', 'key':'hw_algo', 'type':'list', 'values':{'AES-128 (8-bit)':models_AES128_8bit}, 'value':'AES-128', 'set':self.updateScript},
{'name':'Leakage Model', 'key':'hw_leak', 'type':'list', 'values':models_AES128_8bit.leakagemodels, 'value':1, 'set':self.updateScript},
]},
#TODO: Should be called from the AES module to figure out # of bytes
{'name':'Attacked Bytes', 'type':'group', 'children':
self.getByteList()
},
]
self.params = Parameter.create(name='Attack', type='group', children=attackParams)
ExtendedParameter.setupExtended(self.params, self)
self.setAnalysisAlgorithm(CPAProgressive, None, None)
self.updateBytesVisible()
self.updateScript()
def _build_param(self):
#fms = self.framework_settings
#batch_draw_debug_data_opts = self.batch_debug_draw.options
params = [
{'name': 'draw_bits', 'type': 'group', 'children':
[
{'name': 'draw shapes', 'type': 'bool', 'value': False},
{'name': 'draw joints', 'type': 'bool', 'value': False},
{'name': 'draw aabb', 'type': 'bool', 'value': False},
{'name': 'draw pairs', 'type': 'bool', 'value': False},
{'name': 'draw center of mass', 'type': 'bool', 'value': False},
{'name': 'draw particle', 'type': 'bool', 'value': False},
]
},
{'name': 'particles', 'type': 'group', 'children':
[
{'name': 'colored', 'type': 'bool', 'value': False},
]
}
]
# batch_draw_debug_data_opts.draw_shapes = fms.draw_shapes
# batch_draw_debug_data_opts.draw_joints = fms.draw_joints
# batch_draw_debug_data_opts.draw_aabbs = fms.draw_aabbs
# batch_draw_debug_data_opts.draw_coms = fms.draw_coms
self.parameter = Parameter.create(name='Debug Draw', type='group', children=params)
draw_bit_param = self.parameter.param('draw_bits')
for child in draw_bit_param.children():
child.sigValueChanged.connect(self.on_debug_draw_bits_changed)
def set_paratree(self):
global p, name
params = []
if self.isInputs:
inp_dict = {'name': u'Eingänge', 'type': 'group', 'expanded': True}
else:
inp_dict = {'name': u'Befehle', 'type': 'group', 'expanded': True}
inp_kinder = []
for aktuator in sorted(self.inputs):
if (aktuator.get('Description') <> None and self.inputsGroup in aktuator.get('Name') and self.isInputs) or (not self.isInputs and not aktuator.get('Name') in ['Name']):
if self.isInputs:
title = aktuator.get('Description')
else:
title = str(aktuator.get('Name'))
akt_dict = {'name': str(aktuator.get('Id')), 'title':title , 'type': 'group', 'expanded': False}
if self.expand == aktuator.get('Name'):
akt_dict['expanded']= True
kinder1 = []
kinder2 = []
kinder3, kinder4 = [], []
for sub in sorted(aktuator):
if sub in ['Logging','Setting','Doppelklick']:
if aktuator.get(sub) == '1':
kinder1.append({'name': sub, 'type': 'bool', 'value':True})
elif aktuator.get(sub) in ['0', None]:
kinder1.append({'name': sub, 'type': 'bool', 'value':False})
else:
kinder1.append({'name': sub, 'type': 'bool', 'value':eval(aktuator.get(sub))})
elif sub in ['Description']:
kinder2.append({'name': sub, 'title':'Beschreibung', 'type': 'str', 'value':aktuator.get(sub)})
elif sub in ['Value_lt','Value_eq','Value_gt']:
kinder3.append({'name': sub, 'type': 'str', 'value':aktuator.get(sub)})
elif sub in ['Immer','Wach','Wecken','Schlafen','Schlummern','Leise','AmGehen','Gegangen','Abwesend','Urlaub','Besuch','Doppel','Dreifach']:
kinder4.append({'name': sub, 'type': 'list','value': aktuator.get(sub), 'values':self._szn_lst})
elif sub in ['Id']:
pass
else:
kinder2.append({'name': sub, 'type': 'str', 'value':aktuator.get(sub)})
kinder = kinder1 + kinder2 + kinder3 + kinder4
akt_dict['children'] = kinder
inp_kinder.append(akt_dict)
inp_dict['children'] = inp_kinder
params.append(inp_dict)
if self.isInputs:
inp_dict = {'name': 'Aktionen', 'type': 'group', 'children': [
{'name': 'Speichere Inputs', 'type': 'action'}
]}
params.append(inp_dict)
else:
inp_dict = {'name': 'Aktionen', 'type': 'group', 'children': [
{'name': 'Speichere', 'type': 'action'},
{'name': 'Neues Kommando', 'type': 'action'}
]}
params.append(inp_dict)
self.p = Parameter.create(name='params', type='group', children=params)
if self.isInputs:
self.p.param('Aktionen', 'Speichere Inputs').sigActivated.connect(self.save)
else:
self.p.param('Aktionen', 'Speichere').sigActivated.connect(self.save)
self.p.param('Aktionen', 'Neues Kommando').sigActivated.connect(self.newCommand)
def __init__(self, parent = None):
#print "init!!!!!"
self.parent = parent
## Dock: Labels
self.dLabels = Dock("Labels", size=(1, 1))
self.wLabels = ParameterTree()
self.wLabels.setWindowTitle('Labels')
self.dLabels.addWidget(self.wLabels)
self.labels_grp = 'Labels'
self.labels_A_str = 'Single'
self.labels_B_str = 'Multi'
self.labels_C_str = 'Dunno'
self.labelA = False
self.labelB = False
self.labelC = False
#######################
# Mandatory parameter #
#######################
self.params = [
{'name': self.labels_grp, 'type': 'group', 'children': [
{'name': self.labels_A_str, 'type': 'bool', 'value': self.labelA, 'tip': "Single"},
{'name': self.labels_B_str, 'type': 'bool', 'value': self.labelB, 'tip': "Multi"},
{'name': self.labels_C_str, 'type': 'bool', 'value': self.labelC, 'tip': "Dunno"},
]},
]
self.pLabels = Parameter.create(name='paramsLabel', type='group', \
children=self.params, expanded=True)
self.pLabels.sigTreeStateChanged.connect(self.change)
self.wLabels.setParameters(self.pLabels, showTop=False)
def __init__(self):
super(ResultsPlotting, self).__init__()
self.override = None
#ResultsTable manages class
self.table = ResultsTable()
self.table.setKeyOverride(self.processKnownKey)
self.graphoutput = OutputVsTime()
self.GraphOutputDock = QDockWidget(self.graphoutput.name)
self.GraphOutputDock.setObjectName(self.graphoutput.name)
self.GraphOutputDock.setAllowedAreas(Qt.BottomDockWidgetArea | Qt.RightDockWidgetArea| Qt.LeftDockWidgetArea)
self.GraphOutputDock.setWidget(self.graphoutput)
self.graphoutput.setDock(self.GraphOutputDock)
self.graphoutput.setKeyOverride(self.processKnownKey)
self.pgegraph = PGEVsTrace()
self.PGEGraphDock = QDockWidget(self.pgegraph.name)
self.PGEGraphDock.setObjectName(self.pgegraph.name)
self.PGEGraphDock.setAllowedAreas(Qt.BottomDockWidgetArea | Qt.RightDockWidgetArea| Qt.LeftDockWidgetArea)
self.PGEGraphDock.setWidget(self.pgegraph)
self.pgegraph.setDock(self.PGEGraphDock)
self.pgegraph.setKeyOverride(self.processKnownKey)
self.saveresults = ResultsSave()
resultsParams = [{'name':'Knownkey Source', 'type':'list', 'values':{'Attack Module':'attack', 'GUI Override':'gui'},
'value':'attack', 'set':self.setKnownKeySrc},
{'name':'Override Key', 'type':'str', 'key':'knownkey', 'value':'', 'set':self.setKnownKeyStr, 'readonly':True},
{'name':'Save Raw Results', 'type':'bool', 'value':False, 'set':self.saveresults.setEnabled}
]
self.params = Parameter.create(name="General Parameters", type='group', children=resultsParams)
ExtendedParameter.setupExtended(self.params, self)
def set_paratree(self):
global p, name
params = []
dicti = {'name': u'Settings', 'type': 'group', 'expanded': True}
kinder = []
for seti in sets:
kind = {'name':seti.get('Name')}
if seti.get('Typ') == None:
kind['type'] = 'str'
kind['value'] = seti.get('Value')
elif '[' in seti.get('Typ'):
kind['type'] = 'list'
kind['values']=self.__return_enum__(seti.get('Typ'))
kind['value'] = seti.get('Value')
else:
kind['type'] =seti.get('Typ')
kind['value'] = eval(seti.get('Value'))
kinder.append(kind)
dicti['children'] = kinder
inp_dict = {'name': 'Aktionen', 'type': 'group', 'children': [
{'name': 'Speichern', 'type': 'action'}
]}
params.append(dicti)
params.append(inp_dict)
self.p = Parameter.create(name='params', type='group', children=params)
self.p.param('Aktionen', 'Speichern').sigActivated.connect(self.save)
def __init__(self, parent = None, savedstate=None):
super(ProjectSettingsDialog, self).__init__(parent)
self.setWindowTitle("Application Settings")
layout = QtGui.QVBoxLayout(self)
self.initKeyParamMapping()
self._settings = Parameter.create(name='params', type='group', children=settings_params)
if savedstate:
self._settings.restoreState(savedstate)
# Holds settings keys that have changed by the user when the
# dialog is closed. Used to update any needed gui values..
self._updated_settings={}
self._settings.sigTreeStateChanged.connect(self.handleSettingChange)
self.initSettingsValues()
self.ptree = ParameterTree()
self.ptree.setParameters(self._settings, showTop=False)
self.ptree.setWindowTitle('MarkWrite Application Settings')
layout.addWidget(self.ptree)
self.ptree.adjustSize()
# OK and Cancel buttons
self.buttons = QtGui.QDialogButtonBox(
QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel,
QtCore.Qt.Horizontal, self)
layout.addWidget(self.buttons)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.resize(500,700)
def setupParameters(self):
ssParams = [{'name':'STK500.exe Path', 'type':'str', 'key':'stk500path', 'value':r'C:\Program Files (x86)\Atmel\AVR Tools\STK500\Stk500.exe'},
{'name':'AVR Part', 'type':'list', 'key':'part', 'values':['atmega328p'], 'value':'atmega328p'},
{'name':'Test Reset', 'type':'action', 'action':self.testReset}
]
self.params = Parameter.create(name='Reset AVR via STK500', type='group', children=ssParams)
ExtendedParameter.setupExtended(self.params, self)
def setupParameters(self):
self.oa=None
self.driver = None
supported_readers = dicttype()
supported_readers["Select Reader"] = None
supported_readers["ChipWhisperer-SER"] = ReaderChipWhispererSER()
supported_readers["ChipWhisperer-USI"] = ReaderChipWhispererUSI()
supported_readers["ChipWhisperer-SCARD"] = ReaderChipWhispererSCard()
supported_readers["System Serial (SASEBO-W)"] = ReaderSystemSER()
try:
supported_readers["PC/SC Reader"] = ReaderPCSC()
except ImportError:
pass
ssParams = [{'name':'Reader Hardware', 'type':'list', 'values':supported_readers, 'value':None, 'set':self.setConnection},
#"BasicCard v7.5 (INCOMPLETE"):None,
#"Custom (INCOMPLETE)":None, "DPAContestv4 (INCOMPLETE)":None
{'name':'SmartCard Protocol', 'type':'list', 'values':{"SASEBO-W SmartCard OS":ProtocolSASEBOWCardOS(),
"ChipWhisperer-Dumb":None,
"JCard Test":ProtocolJCardTest(),
"DPA Contest 4.2":ProtocolDPAv42(),
}, 'value':None, 'set':self.setProtocol}
]
self.params = Parameter.create(name='Target Connection', type='group', children=ssParams)
ExtendedParameter.setupExtended(self.params, self)
def __init__(self, parent, showScriptParameter=None, tmanager=None, console=None):
super(ProfilingTemplate, self).__init__()
if console:
self.console = console
self.setParent(parent)
self._tmanager = None
self._project = None
resultsParams = [{'name':'Load Template', 'type':'group', 'children':[
]},
{'name':'Generate New Template', 'type':'group', 'children':[
{'name':'Trace Start', 'key':'tgenstart', 'value':0, 'type':'int', 'set':self.updateScript},
{'name':'Trace End', 'key':'tgenstop', 'value':self.parent().traceMax, 'type':'int', 'set':self.updateScript},
{'name':'POI Selection', 'key':'poimode', 'type':'list', 'values':{'TraceExplorer Table':0, 'Read from Project File':1}, 'value':0, 'set':self.updateScript},
{'name':'Read POI', 'type':'action', 'action':self.updateScript},
{'name':'Generate Templates', 'type':'action', 'action': lambda:self.runScriptFunction.emit("generateTemplates")}
]},
]
self.params = Parameter.create(name='Template Attack', type='group', children=resultsParams)
if showScriptParameter is not None:
self.showScriptParameter = showScriptParameter
# print self.showScriptParameter
ExtendedParameter.setupExtended(self.params, self)
self.addGroup("generateTemplates")
self.sr = None
self.stats = DataTypeDiffs()
self.setProfileAlgorithm(TemplateBasic)
def setupUi(self, MainWindow, params):
#app = QtGui.QApplication([])
#self.win = QtGui.QMainWindow()
self.area = DockArea()
MainWindow.setCentralWidget(self.area)
MainWindow.resize(500, 700)
MainWindow.setWindowTitle('Action construct')
self.seq_cntr = Dock("Sequence", size=(150,200))
self.area.addDock(self.seq_cntr, 'left')
## first dock gets save/restore buttons
self.t = ParameterTree()
if params != None:
self.p_child = Parameter.create(name='params', type='group', children=params)
self.t.setParameters(self.p_child, showTop=False)
self.t.setWindowTitle('pyqtgraph example: Parameter Tree')
self.seq_cntr.addWidget(self.t)
self.seq = pg.LayoutWidget()
self.label = QtGui.QLabel("""Controls""")
self.saveBtn = QtGui.QPushButton('Add Action')
self.restoreBtn = QtGui.QPushButton('Modify table')
self.restoreBtn.setEnabled(False)
self.seq.addWidget(self.label, row=0, col=0)
self.seq.addWidget(self.saveBtn, row=1, col=0)
self.seq.addWidget(self.restoreBtn, row=2, col=0)
self.seq_cntr.addWidget(self.seq)
def __init__(self, project=None, parent=None):
QMainWindow.__init__(self, parent=parent)
widget = QWidget(self)
layout = QGridLayout(widget)
self.title = 'Feature Extractor'
self.setWindowTitle(self.title)
self.project = project
self.feature_extractor = FeatureExtractor()
classifier_dir = self.project.project_file + '_classifier' if project is not None else ''
if os.path.isfile(os.path.join(classifier_dir, '_feature_extractor.json')):
self.feature_extractor.load_settings(os.path.join(classifier_dir, '_feature_extractor.json'))
self.setCentralWidget(widget)
self.terminal = QTextBrowser(self)
self._err_color = QtCore.Qt.red
self.button1 = QPushButton('Set Project feature Extractor', self)
self.button1.clicked.connect(self.setProjectFeatureExtraction)
self.button2 = QPushButton('Extract!', self)
self.button2.clicked.connect(self.runFeatureExtraction)
self.progressBar0 = QProgressBar()
self.progressBar1 = QProgressBar()
self.params = settings2params(self.feature_extractor.settings)
## Create tree of Parameter objects
self.p = Parameter.create(name='params', type='group', children=self.params)
self.t = PyecogParameterTree()
self.t.setParameters(self.p, showTop=False)
self.t.headerItem().setHidden(True)
layout.addWidget(self.t)
layout.setRowStretch(0,10)
layout.setRowMinimumHeight(0,400)
layout.setColumnMinimumWidth(0,600)
layout.addWidget(self.button1)
layout.addWidget(self.button2)
layout.addWidget(self.progressBar0)
layout.addWidget(self.progressBar1)
layout.addWidget(self.terminal)
layout.setRowMinimumHeight(5,300)
stdout = OutputWrapper(self, True)
stdout.outputWritten.connect(self.handleOutput)
stderr = OutputWrapper(self, False)
stderr.outputWritten.connect(self.handleOutput)
self.threadpool = QtCore.QThreadPool()
self.dfrmt = '%Y-%m-%d %H:%M:%S' # Format to use in date elements
def __init__(self, annotations):
PyecogParameterTree.__init__(self)
self.annotationPage = annotations
labels = self.annotationPage.labels
self.shortcut_keys = dict([(l, i + 1) for i, l in enumerate(labels)])
print('Labels:', labels)
Label_initial_dict = [{
'name':
label,
'type':
'group',
'children': [{
'name': 'shortcut key',
'type': 'int',
'value': self.shortcut_keys[label],
'limits': (1, 10)
}, {
'name': 'color',
'type': 'color',
'value': self.annotationPage.label_color_dict[label]
}, {
'name':
'Channel range',
'type':
'str',
'value':
str(self.annotationPage.label_channel_range_dict[label])
}],
'renamable':
True,
'removable':
True
} for i, label in enumerate(labels)]
self.params = [
ScalableGroup(name="Annotation Labels",
children=Label_initial_dict)
]
## Create tree of Parameter objects
self.p = Parameter.create(name='params',
type='group',
children=self.params)
self.p.sigTreeStateChanged.connect(self.change)
self.setParameters(self.p, showTop=False)
self.headerItem().setHidden(True)
# self.update_color_from_group_parameters()
# self.last_label_change = None
self.annotationPage.sigLabelsChanged.connect(self.re_init)
def __init__(self, chname):
global area, params, ptree, args
self.name = chname
self.d = Dock(chname, size=(500, 300))
self.w = pg.PlotWidget()
self.curve = self.w.plot()
self.w.showGrid(x=True, y=True)
self.w.setTitle(chname)
self.d.addWidget(self.w)
area.addDock(self.d, 'bottom')
self.params = Parameter.create(name=chname,
type='group',
children=[{
'name':
'Color',
'type':
'color',
'value':
"0CC",
'tip':
"This is a color button"
}, {
'name':
'Scrolling',
'type':
'group',
'expanded':
False,
'children': [
{
'name': 'Scrolling',
'type': 'bool',
'value': False
},
{
'name': 'Range (seconds)',
'type': 'int',
'value': 300
},
]
}])
params.addChild(self.params)
ptree.setParameters(params, showTop=False)
return
def setParameters(self, parameter: Parameter):
parameter.blockSignals(True)
for child in parameter.children():
child.blockSignals(True)
self.processeditor.setParameters(parameter, showTop=False)
QApplication.processEvents()
parameter.blockSignals(False)
for child in parameter.children():
child.blockSignals(False)
def __init__(self, h5_file_path=None, h5_file=None, save_type='scan'):
"""Initialize the H5Saver object
Creates the ``setting`` and ``settings_tree`` object
"""
super(H5Saver, self).__init__()
if save_type not in save_types:
raise Exception('Invalid saving type')
self.h5_file = h5_file
self.h5_file_path = h5_file_path
self.h5_file_name = None
self.logger_array = None
self.current_group = None
self.current_scan_group = None
self.current_scan_name = None
self.raw_group = None
self.settings = Parameter.create(title='Saving settings',
name='save_settings',
type='group',
children=self.params)
self.settings_tree = ParameterTree()
self.settings_tree.setMinimumHeight(310)
self.settings_tree.setParameters(self.settings, showTop=False)
self.settings.child(
('current_h5_file'
)).sigActivated.connect(lambda: self.emit_new_file(True))
self.settings.child(('save_type')).setValue(save_type)
self.filters = tables.Filters(
complevel=self.settings.child('compression_options',
'h5comp_level').value(),
complib=self.settings.child('compression_options',
'h5comp_library').value())
# self.settings.child('saving_options', 'save_independent').show(save_type == 'scan')
# self.settings.child('saving_options', 'do_save').show(not save_type == 'scan')
# self.settings.child('saving_options', 'current_scan_name').show(save_type == 'scan')
self.settings.sigTreeStateChanged.connect(
self.parameter_tree_changed
) # any changes on the settings will update accordingly the detector
def setupTraceParam(self):
self.traceParams = Parameter.create(name='Trace Setup',
type='group',
children=[
{
'name': 'Starting Trace',
'key': 'strace',
'type': 'int',
'set':
self.updateGenericScript
},
{
'name':
'Traces per Attack',
'key': 'atraces',
'type': 'int',
'limits': (1, 1E6),
'value': 1,
'set':
self.updateGenericScript
},
{
'name': 'Attack Runs',
'key': 'runs',
'type': 'int',
'limits': (1, 1E6),
'value': 1,
'set':
self.updateGenericScript
},
{
'name':
'Reporting Interval',
'key': 'reportinterval',
'type': 'int',
'value': 10,
'set':
self.updateGenericScript
},
])
ExtendedParameter.setupExtended(self.traceParams, self)
self.addFunction("init", "setTraceStart", "0")
self.addFunction("init", "setTracesPerAttack", "1")
self.addFunction("init", "setIterations", "1")
self.addFunction("init", "setReportingInterval", "10")
self.singleEmit = True
def __init__(self, name):
terminals = {
'sig': {
'io': 'in'
},
'ref': {
'io': 'in'
},
'bkg': {
'io': 'in'
},
'sigMask': {
'io': 'in'
},
'ref1': {
'io': 'out',
'bypass': '******'
}
}
super().__init__(name, terminals=terminals)
paras_property = [{
'name': 'rank',
'type': 'int',
'readonly': True
}, {
'name': 'rankLimit',
'type': 'int',
'value': 100
}, {
'name': 'trunc',
'type': 'float'
}, {
'name': 'updateLib',
'type': 'bool'
}, {
'name': 'reset',
'type': 'action'
}]
self.paras = Parameter.create(name='params',
type='group',
children=paras_property)
self.paratree = ParameterTree()
self.paratree.setParameters(self.paras, showTop=False)
self.remover = FringeRemove()
self.paras.param('reset').sigActivated.connect(self.remover.reset)
def __init__(self, parent = None):
self.parent = parent
## Dock: Quantifier
self.dock = Dock("Small Data", size=(100, 100))
self.win = ParameterTree()
self.dock.addWidget(self.win)
self.winL = pg.LayoutWidget()
self.refreshBtn = QtGui.QPushButton('Refresh')
self.winL.addWidget(self.refreshBtn, row=0, col=0)
self.peakogramBtn = QtGui.QPushButton('Peakogram')
self.winL.addWidget(self.peakogramBtn, row=0, col=1)
self.dock.addWidget(self.winL)
# Add plot
self.winP = pg.PlotWidget(title="Metric")
self.dock.addWidget(self.winP)
# Quantifier parameter tree
self.quantifier_grp = 'Small data'
self.quantifier_filename_str = 'filename'
self.quantifier_dataset_str = 'dataset'
self.quantifier_sort_str = 'sort'
# Quantifier
self.quantifier_filename = ''
self.quantifier_dataset = '/entry_1/result_1/'
self.quantifier_sort = False
self.quantifierFileOpen = False
self.quantifierHasData = False
self.params = [
{'name': self.quantifier_grp, 'type': 'group', 'children': [
{'name': self.quantifier_filename_str, 'type': 'str', 'value': self.quantifier_filename, 'tip': "Full path Hdf5 filename"},
{'name': self.quantifier_dataset_str, 'type': 'str', 'value': self.quantifier_dataset, 'tip': "Hdf5 dataset metric, nPeaksAll or nHitsAll"},
{'name': self.quantifier_sort_str, 'type': 'bool', 'value': self.quantifier_sort, 'tip': "Ascending sort metric"},
]},
]
self.pSmall = Parameter.create(name='paramsQuantifier', type='group', \
children=self.params, expanded=True)
self.win.setParameters(self.pSmall, showTop=False)
self.pSmall.sigTreeStateChanged.connect(self.change)
if using_pyqt4:
self.parent.connect(self.refreshBtn, QtCore.SIGNAL("clicked()"), self.reloadQuantifier)
self.parent.connect(self.peakogramBtn, QtCore.SIGNAL("clicked()"), self.showPeakogram)
else:
self.refreshBtn.clicked.connect(self.reloadQuantifier)
self.peakogramBtn.clicked.connect(self.showPeakogram)
def set_point_list(self):
dock_list = Dock('List of points')
self.area.addDock(dock_list, 'right')
params = [
{
'title': 'Positions',
'name': 'tabular_table',
'type': 'table_view',
'delegate': gutils.SpinBoxDelegate,
'menu': True
},
]
self.settings_tree = ParameterTree()
self.settings = Parameter.create(name='settings',
title='Settings',
type='group',
children=params)
self.settings_tree.setParameters(self.settings, showTop=False)
dock_list.addWidget(self.settings_tree)
init_data = [[0., 0., 0.]]
self.table_model = TableModelTabular(init_data, ['x', 'y', 'data'])
self.table_view = custom_tree.get_widget_from_tree(
self.settings_tree, custom_tree.TableViewCustom)[0]
self.settings.child(('tabular_table')).setValue(self.table_model)
self.table_view.horizontalHeader().setResizeMode(
QtWidgets.QHeaderView.ResizeToContents)
self.table_view.horizontalHeader().setStretchLastSection(True)
self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
styledItemDelegate = QtWidgets.QStyledItemDelegate()
styledItemDelegate.setItemEditorFactory(gutils.SpinBoxDelegate())
self.table_view.setItemDelegate(styledItemDelegate)
self.table_view.setDragEnabled(True)
self.table_view.setDropIndicatorShown(True)
self.table_view.setAcceptDrops(True)
self.table_view.viewport().setAcceptDrops(True)
self.table_view.setDefaultDropAction(Qt.MoveAction)
self.table_view.setDragDropMode(QtWidgets.QTableView.InternalMove)
self.table_view.setDragDropOverwriteMode(False)
self.table_view.add_data_signal[int].connect(self.table_model.add_data)
self.table_view.remove_row_signal[int].connect(
self.table_model.remove_data)
self.table_view.load_data_signal.connect(self.table_model.load_txt)
self.table_view.save_data_signal.connect(self.table_model.save_txt)
def display_tree_widget(self, fish):
"""Display the parameter tree from the experiment metadata.
:param metadata: .json metadata
"""
self.fish = fish
print(self.fish)
self.fish_folder = Path(self.data_directory + '/{}/'.format(self.fish.text()))
self.fish_metadata_path = list(self.fish_folder.glob('*.json'))
with open(self.fish_metadata_path) as json_file:
self.metadata = json.load(json_file)
# Close previous tree widget
self.close_tree()
# Create a variable checking whether changes have been made to the parameter tree values
self.has_changed = False
# Create list with parameters for the tree
self.parameters = self.create_parameters(self.fix_types(self.metadata))
# Create tree of Parameter objects
self.p = Parameter.create(name='params', type='group', children=self.parameters)
# Save original state
self.original_state = self.p.saveState()
# Create ParameterTree widget
self.tree = ParameterTree()
self.tree.setParameters(self.p, showTop=False)
self.tree.setWindowTitle('pyqtgraph example: Parameter Tree')
# Display tree widget
self.layout.addWidget(self.tree, 0, 0, 1, 2)
# And buttons
self.savebtn = QPushButton("Save changes")
self.resetbtn = QPushButton("Reset changes")
self.layout.addWidget(self.savebtn, 3, 0)
self.layout.addWidget(self.resetbtn, 3, 1)
self.savebtn.clicked.connect(self.save_treevals)
self.resetbtn.clicked.connect(self.reset)
# Send signal when any entry is changed
self.p.sigTreeStateChanged.connect(self.change)
def __init__(self, parent=None, ipaddress="192.168.1.62", port=6341, params_state=None, client_type="GRABBER"):
super().__init__()
self.ipaddress = ipaddress
self.port = port
self.settings = Parameter.create(name='Settings', type='group', children=self.params)
if params_state is not None:
if isinstance(params_state, dict):
self.settings.restoreState(params_state)
elif isinstance(params_state, Parameter):
self.settings.restoreState(params_state.saveState())
self.parent = parent
self.socket = None
self.client_type = client_type #"GRABBER" or "ACTUATOR"
def copy(self):
"""
Method to copy a block
"""
print('coying ..' + self.__class__.__name__)
copyInstance = self.__class__()
copyInstance.__dict__ = self.__dict__.copy()
copyInstance.parameters = Parameter.create(
name=self.parameters.name(), type='group',
children=[]) #children = self.parameters.children()
parametersCopy = self.parameters.saveState()
copyInstance.parameters.restoreState(parametersCopy)
return copyInstance
def __init__(self):
SpectralParameterAdapter.__init__(self)
self.name = self.tr(u'PeaksAbove')
self._settings += [{
u'name': unicode(self.tr(u'Threshold (dB)')),
u'type': u'int',
u'value': -20.00,
u'step': 1,
u'limits': (-100, 0)
}]
self.threshold = -20
self.settings = Parameter.create(name=u'Settings',
type=u'group',
children=self._settings)
def test_unpack_parameter():
# test that **unpacking correctly returns child name/value maps
params = [
dict(name='a', type='int', value=1),
dict(name='b', type='str', value='2'),
dict(name='c', type='float', value=3.0),
]
p = Parameter.create(name='params', type='group', children=params)
result = dict(**p)
assert 'a' in result
assert result['a'] == 1
assert 'b' in result
assert result['b'] == '2'
assert 'c' in result
assert result['c'] == 3.0
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 setupParameters(self):
self.rtrace = 0
self.debugReturnCorr = False
resultsParams = [{'name':'Enabled', 'key':'enabled', 'type':'bool', 'value':True, 'set':self.updateScript},
{'name':'Ref Trace', 'key':'reftrace', 'type':'int', 'value':0, 'set':self.updateScript},
{'name':'Window', 'key':'rwindow', 'type':'rangegraph', 'graphwidget':self.parent.waveformDock.widget(), 'set':self.updateScript},
# {'name':'Output Correlation (DEBUG)', 'type':'bool', 'value':False, 'set':self.setOutputCorr},
{'name':'Desc', 'type':'text', 'value':self.descrString}
]
self.params = Parameter.create(name='Cross Correlation', type='group', children=resultsParams)
ExtendedParameter.setupExtended(self.params, self)
self.ccStart = 0
self.ccEnd = 0
self.updateScript()
def test_unpack_parameter():
# test that **unpacking correctly returns child name/value maps
params = [
dict(name="a", type="int", value=1),
dict(name="b", type="str", value="2"),
dict(name="c", type="float", value=3.0),
]
p = Parameter.create(name="params", type="group", children=params)
result = dict(**p)
assert "a" in result
assert result["a"] == 1
assert "b" in result
assert result["b"] == "2"
assert "c" in result
assert result["c"] == 3.0
def __init__(self, parent=None, params_state=None):
super(DAQ_Viewer_base, self).__init__()
self.parent_parameters_path = [
] #this is to be added in the send_param_status to take into account when the current class instance parameter list is a child of some other class
self.settings = Parameter.create(name='Settings',
type='group',
children=self.params)
if params_state is not None:
if isinstance(params_state, dict):
self.settings.restoreState(params_state)
elif isinstance(params_state, Parameter):
self.settings.restoreState(params_state.saveState())
self.settings.sigTreeStateChanged.connect(self.send_param_status)
self.parent = parent
self.status = edict(info="", controller=None, initialized=False)
self.scan_parameters = None
def set_new_remote(self, file=None):
if file is None:
file = 'remote_default'
param = [
{'title': 'Filename:', 'name': 'filename', 'type': 'str', 'value': file},
]
params_action = [{'title': 'Actuator Actions:', 'name': 'act_actions', 'type': 'groupmodules',
'addList': self.actuators, 'modtype': 'Actuator'},
{'title': 'Detector Actions:', 'name': 'det_actions', 'type': 'groupmodules',
'addList': self.detectors, 'modtype': 'Detector'}
] # PresetScalableGroupMove(name="Moves")]
self.remote_params = Parameter.create(title='Preset', name='Preset', type='group',
children=param + params_action)
self.remote_params.sigTreeStateChanged.connect(self.parameter_tree_changed)
logger.info('Creating a new remote file')
self.show_remote()
def update_settings(self, settings_parameter_dict):
"""
Update the settings tree from settings_parameter_dict.
Finally do a commit to activate changes.
========================== ============= =====================================================
**Parameters** **Type** **Description**
*settings_parameter_dict* dictionnnary a dictionnary listing path and associated parameter
========================== ============= =====================================================
See Also
--------
send_param_status, commit_settings
"""
# settings_parameter_dict=edict(path=path,param=param)
try:
path = settings_parameter_dict['path']
param = settings_parameter_dict['param']
change = settings_parameter_dict['change']
try:
self.settings.sigTreeStateChanged.disconnect(
self.send_param_status)
except:
pass
if change == 'value':
self.settings.child(*path[1:]).setValue(
param.value()) #blocks signal back to main UI
elif change == 'childAdded':
child = Parameter.create(name='tmp')
child.restoreState(param)
self.settings.child(*path[1:]).addChild(
child) #blocks signal back to main UI
param = child
elif change == 'parent':
children = custom_tree.get_param_from_name(
self.settings, param.name())
if children is not None:
path = custom_tree.get_param_path(children)
self.settings.child(*path[1:-1]).removeChild(children)
self.settings.sigTreeStateChanged.connect(self.send_param_status)
self.commit_settings(param)
except Exception as e:
self.emit_status(ThreadCommand("Update_Status", [str(e), 'log']))
def __init__(self):
super(MainWindow, self).__init__()
layout = Qt.QVBoxLayout(self)
self.btnAcq = Qt.QPushButton("Start Acq!")
layout.addWidget(self.btnAcq)
self.SamplingPar = AcqMod.SampSetParam(name='SampSettingConf')
self.Parameters = Parameter.create(name='App Parameters',
type='group',
children=(self.SamplingPar, ))
self.SamplingPar.NewConf.connect(self.on_NewConf)
self.PlotParams = PltMod.PlotterParameters(name='Plot options')
self.PlotParams.SetChannels(self.SamplingPar.GetChannelsNames())
self.PlotParams.param('Fs').setValue(self.SamplingPar.Fs.value())
self.Parameters.addChild(self.PlotParams)
self.PSDParams = PltMod.PSDParameters(name='PSD Options')
self.PSDParams.param('Fs').setValue(self.SamplingPar.Fs.value())
self.Parameters.addChild(self.PSDParams)
self.Parameters.sigTreeStateChanged.connect(self.on_pars_changed)
self.treepar = ParameterTree()
self.treepar.setParameters(self.Parameters, showTop=False)
self.treepar.setWindowTitle('pyqtgraph example: Parameter Tree')
layout.addWidget(self.treepar)
self.setGeometry(650, 20, 400, 800)
self.setWindowTitle('MainWindow')
self.btnAcq.clicked.connect(self.on_btnStart)
self.threadAcq = None
self.threadSave = None
self.threadPlotter = None
self.FileParameters = FileMod.SaveFileParameters(QTparent=self,
name='Record File')
self.Parameters.addChild(self.FileParameters)
self.ConfigParameters = FileMod.SaveSateParameters(
QTparent=self, name='Configuration File')
self.Parameters.addChild(self.ConfigParameters)
def __init__(self,
detectors=[],
actuators=[],
selected_detectors=[],
selected_actuators=[],
timeout=10000):
super().__init__()
for mod in selected_actuators:
assert mod in actuators
for mod in selected_detectors:
assert mod in detectors
self.timeout = timeout # in ms
self.det_done_datas = OrderedDict()
self.det_done_flag = False
self.move_done_positions = OrderedDict()
self.move_done_flag = False
self.settings = Parameter.create(name='Settings',
type='group',
children=self.params)
self.settings_tree = ParameterTree()
self.settings_tree.setMinimumWidth(300)
self.settings_tree.setParameters(self.settings, showTop=False)
self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
self.settings.child('data_dimensions',
'probe_data').sigActivated.connect(
self.get_det_data_list)
self.settings.child('actuators_positions',
'test_actuator').sigActivated.connect(
self.test_move_actuators)
self._detectors = []
self._actuators = []
self.grab_done_signals = []
self.det_commands_signal = []
self.actuators_connected = False
self.detectors_connected = False
self.set_actuators(actuators, selected_actuators)
self.set_detectors(detectors, selected_detectors)
def set_GUI(self):
layout = QtWidgets.QGridLayout()
V_splitter = QtWidgets.QSplitter(Qt.Vertical)
V_splitter2 = QtWidgets.QSplitter(Qt.Vertical)
H_splitter = QtWidgets.QSplitter(Qt.Horizontal)
Form = QtWidgets.QWidget()
#self.ui.h5file_tree = Tree_layout(Form,col_counts=2,labels=["Node",'Pixmap'])
self.ui.h5file_tree = Tree_layout(Form, col_counts=1, labels=["Node"])
self.ui.h5file_tree.ui.Tree.setMinimumWidth(300)
self.ui.h5file_tree.ui.Tree.itemClicked.connect(
self.show_h5_attributes)
self.ui.h5file_tree.ui.Tree.itemDoubleClicked.connect(
self.show_h5_data)
self.export_action = QtWidgets.QAction("Export data as *.txt file")
self.export_action.triggered.connect(self.export_data)
self.ui.h5file_tree.ui.Tree.addAction(self.export_action)
V_splitter.addWidget(Form)
self.ui.attributes_table = custom_tree.Table_custom()
V_splitter.addWidget(self.ui.attributes_table)
H_splitter.addWidget(V_splitter)
self.pixmap_widget = QtWidgets.QWidget()
self.pixmap_widget.setMaximumHeight(100)
V_splitter2.addWidget(self.pixmap_widget)
self.ui.settings_tree = ParameterTree()
self.ui.settings_tree.setMinimumWidth(300)
V_splitter2.addWidget(self.ui.settings_tree)
self.ui.text_list = QtWidgets.QListWidget()
V_splitter2.addWidget(self.ui.text_list)
H_splitter.addWidget(V_splitter2)
form_viewer = QtWidgets.QWidget()
self.hyperviewer = ViewerND(form_viewer)
H_splitter.addWidget(form_viewer)
layout.addWidget(H_splitter)
self.parent.setLayout(layout)
self.settings = Parameter.create(name='Param', type='group')
self.ui.settings_tree.setParameters(self.settings, showTop=False)
def save_the_graph(self):
exporter = pg.exporters.ImageExporter.ImageExporter(
ui.graphicsView.plotItem)
exporter.parameters()['width'] = 1920
exporter.parameters()['background'] = 'w'
exporter.export('graphique_exporte.png')
src = 'graphique_exporte.png'
dst = self.ui.PathToFile_lineEdit.text(
) #'C:\Users\ggotthar\Desktop\graphique_exporte.png'
shutil.move(src, dst)
print self.ui.PathToFile_lineEdit.text(
), 'is the path where you saved the graph!'
self.p = Parameter.create(name='params',
type='group',
children=self.params)
self.ui.widget.setSelectionMode(
QtGui.QAbstractItemView.ExtendedSelection)
self.ui.widget.setParameters(self.p, showTop=False)
graph_param = self.p.param('Graphics Parameters')
legonoff = graph_param.param('Legend')
legonoff.sigValueChanged.connect(change_legend_on_off)
X_axis = graph_param.param('X_axis')
X_axis.sigValueChanged.connect(change_X_axis_on_off)
Y_left_axis = graph_param.param('Y(left)_axis')
Y_left_axis.sigValueChanged.connect(change_Y_left_axis_on_off)
Y_right_axis = graph_param.param('Y(right)_axis')
Y_right_axis.sigValueChanged.connect(change_Y_right_axis_on_off)
Xmin = graph_param.param('X_min')
Xmax = graph_param.param('X_max')
Xmin.sigValueChanged.connect(change_X_axis_min_max)
Xmax.sigValueChanged.connect(change_X_axis_min_max)
Pen_width = graph_param.param('Line_width')
Pen_width.sigValueChanged.connect(change_pen_width)
Pen_style = graph_param.param('Line_style')
Pen_style.sigValueChanged.connect(change_pen_style)
colorization = self.ui.graphicsView_2
colorization.sigGradientChanged.connect(change_colorization)
def __init__(self, database_name):
DbLogger.__init__(self,
database_name,
ip_address=config['network']['logging']['sql']['ip'],
port=config['network']['logging']['sql']['port'],
save2D=False)
QtCore.QObject.__init__(self)
self.settings = Parameter.create(title='DB settings',
name='db_settings',
type='group',
children=self.params)
self.settings.child(('do_save')).hide()
self.settings_tree = ParameterTree()
self.settings_tree.setMinimumHeight(310)
self.settings_tree.setParameters(self.settings, showTop=False)
self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
def setupParameterTree(self, makeTree=True):
if self.adc_settings is None:
self.adc_settings = openadc.OpenADCSettings(self.console)
self.params = Parameter.create(
name='OpenADC',
type='group',
children=self.adc_settings.parameters(doUpdate=False))
#ExtendedParameter.setupExtended(self.params)
ep = ExtendedParameter()
ep.setupExtended(self.params, self)
#todo: this is a somewhat insane way to cut through the layers
self.adc_settings.setFindParam(self.findParam)
if makeTree:
self.paramTree = ParameterTree()
self.paramTree.setParameters(self.params, showTop=False)
def setProtocols(self):
"""
Update the prototocls to correspond to the current parameters, top protocol selected
"""
if self.tree == None:
raise ValueError('setProtocols: Must set up read data before setting up protocols')
self.protocols = [
{'name': 'Protos', 'type': 'group', 'children':
[{'name': 'Protocols', 'type': 'list',
'values': self.tree[self.current_DSC][:], 'value': self.tree[self.current_DSC][0]}]
}
]
self.prottreedata = Parameter.create(name='protocol', type='group', children=self.protocols)
self.prottree.setParameters(self.prottreedata)
self.current_protocol = self.tree[self.current_DSC][0]
self.prottreedata.sigTreeStateChanged.connect(self.get_current)
return self.protocols
def setupParameters(self):
ssParams = [{
'name': 'baud',
'type': 'int',
'key': 'baud',
'value': 38400,
'limits': (500, 2000000),
'get': self.baud,
'set': self.setBaud
}]
self.params = Parameter.create(name='Serial Port Settings',
type='group',
children=ssParams)
ExtendedParameter.setupExtended(self.params, self)
self.cwlite_usart = None
self.oa = None
def __init__(self):
super(module, self).__init__()
moreparams = [{
'name': 'SubModule',
'type': 'list',
'values': {
'sm1': submodule(),
'sm2': submodule(),
'sm3': submodule()
},
'set': self.setSubmodule
}]
self.params = Parameter.create(name='Test',
type='group',
children=moreparams)
ExtendedParameter.setupExtended(self.params)
self.sm = None
def set_new_preset(self):
param = [
{
'title': 'Filename:',
'name': 'filename',
'type': 'str',
'value': 'preset_default'
},
{
'title': 'Author:',
'name': 'author',
'type': 'str',
'value': 'Aurore Avargues'
},
{
'title': 'Saving options:',
'name': 'saving_options',
'type': 'group',
'children': H5Saver.params
},
]
params_action = [{
'title': 'Actions:',
'name': 'actions',
'type': 'groupshortcut',
'addList': self.list_actions
}] # PresetScalableGroupMove(name="Moves")]
self.shortcut_params = Parameter.create(title='Preset',
name='Preset',
type='group',
children=param + params_action)
self.shortcut_params.child('saving_options', 'save_type').hide()
self.shortcut_params.child('saving_options', 'save_2D').hide()
self.shortcut_params.child('saving_options', 'do_save').hide()
self.shortcut_params.child('saving_options', 'N_saved').hide()
self.shortcut_params.child('saving_options', 'custom_name').hide()
self.shortcut_params.child('saving_options', 'show_file').hide()
self.shortcut_params.child('saving_options',
'current_scan_name').hide()
self.shortcut_params.child('saving_options',
'current_scan_path').hide()
self.shortcut_params.child('saving_options', 'current_h5_file').hide()
self.shortcut_params.sigTreeStateChanged.connect(
self.parameter_tree_changed)
self.show_preset()
