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, 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 setupParameters(self):
self.hdev = HIDSPI()
ssParams = [{'name':'Jump to Bootloader', 'type':'action', 'action':self.hdev.jumpBootloader}
]
self.params = Parameter.create(name='Target Connection', type='group', children=ssParams)
ExtendedParameter.setupExtended(self.params, self)
self.keylength = 16
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 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):
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 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 __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 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 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 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 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 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, 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, prefDock):
self.Gui = prefDock.Gui
super(mainTab, self).__init__()
## Create tree of Parameter objects
self.p= Parameter.create(name='params', type='group')
#add parameters
self.pAddWidget = self.p.addChild(
{'name': 'Add widget', 'type': 'action'})
self.pSaveRestoreLayout = self.p.addChild(
{'name': 'Save/Restore widget-layout', 'type': 'group', 'children': [
{'name': 'Save', 'type': 'action', 'children': [
{'name': 'Save to file', 'type': 'bool', 'value': False},
{'name': 'Filename', 'type': 'str', 'value': 'preferences/my_widget_layout'},
]},
{'name': 'Restore', 'type': 'action', 'children': [
{'name': 'Restore from file', 'type': 'bool', 'value': False},
{'name': 'Filename', 'type': 'str', 'value': 'preferences/my_widget_layout'},
]},
]})
if self.Gui.interactive:
self.pPlotRates = self.p.addChild(
readoutPlotRates(self.Gui, name='Readout/Plot-Rates'))
#signals
self.pAddWidget.sigActivated.connect(prefDock.createNewDisplay)
self.pSaveRestoreLayout.param(
'Save').sigActivated.connect(self.saveWidgetLayout)
self.pSaveRestoreLayout.param(
'Restore').sigActivated.connect(self.restoreWidgetLayout)
self.setParameters(self.p, showTop=False)
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 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, 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 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,display, prefDock):
self.Gui = prefDock.Gui
self.prefDock = prefDock
self.display = display
super(preferenceTab, self).__init__()
self.p = Parameter.create(name='params', type='group')
#add parameters
self.pRemoveWidget = self.p.addChild(
{'name': 'Remove widget', 'type': 'action'})
self.plot_merge_dims = self.p.addChild(
plotMergeDims(self, self.display, name='Plot merge-dimensions'))
self.slice_image = self.p.addChild(
sliceImage(self, self.display, name='Slice Image'))
self.plot_basis_dims = self.p.addChild(
plotBasisDims(self, self.display, name='Plot basis-dimensions'))
self.pAddContentOf = self.p.addChild(
addContentOf(self, self.display, name='add Content of...'))
self.pViewOptions = self.p.addChild(
viewOptions(self, self.display, name='View Options'))
self.pPlotOptions = self.p.addChild(
plotOptions(self, self.display, name='Plot Options'))
self.save_restore = self.p.addChild(
saveRestorePrefs(self, name='Save/Restore preferences'))
#signals
self.pRemoveWidget.sigActivated.connect(self.remove)
if self.Gui.printChanges:
self.p.sigTreeStateChanged.connect(self.printChange)
self.setParameters(self.p, showTop=False)
#autosave
self.statePreferences = self.p.saveState()
self.showTabOnClick()
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':'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 __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 __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 __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 _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 __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 __buildUI__(self):
mainLayout = QGridLayout()
self.settingsTree1 = ParameterTree(showHeader=True)
self.p = Parameter.create(name='params',
type='group',
children=self.params)
self.settingsTree1.setParameters(self.p, showTop=False)
mainLayout.addWidget(self.settingsTree1)
self.setLayout(mainLayout)
# for child in self.p.children():
# child.sigValueChanging.connect(self.valueChanging)
# for ch2 in child.children():
# ch2.sigValueChanging.connect(self.valueChanging)
beamformingSettings = self.p.child('Beamforming Tab')
def set_file_roi(self, filename, show=True):
"""
"""
children = pymodaq.daq_utils.parameter.ioxml.XML_file_to_parameter(
filename)
self.roi_presets = Parameter.create(title='roi',
name='rois',
type='group',
children=children)
det_children = [
child for child in self.roi_presets.children()
if 'det' in child.opts['name']
]
det_names = [
child.child(('detname')).value()
for child in self.roi_presets.children()
if 'det' in child.opts['name']
]
det_module_names = [det.title for det in self.detector_modules]
for ind_det, det_roi in enumerate(det_children):
det_module = self.detector_modules[det_module_names.index(
det_names[ind_det])]
viewer_children = [
child for child in det_roi.children()
if 'viewer' in child.opts['name']
]
for ind_viewer, viewer in enumerate(det_module.ui.viewers):
rois_params = [
child for child in viewer_children[ind_viewer].children()
if 'ROI' in child.opts['name']
]
if hasattr(viewer, 'roi_manager'):
# if hasattr(viewer.ui, 'roiBtn'):
# viewer.ui.roiBtn.click()
# elif hasattr(viewer.ui, 'Do_math_pb'):
# viewer.ui.Do_math_pb.click()
viewer.roi_manager.load_ROI(params=rois_params)
QtWidgets.QApplication.processEvents()
if show:
self.show_rois()
def update_settings(
self, settings_parameter_dict
): # settings_parameter_dict=edict(path=path,param=param)
"""
Receive the settings_parameter signal from the param_tree_changed method and make hardware updates of mmodified values.
========================== =========== ==========================================================================================================
**Arguments** **Type** **Description**
*settings_parameter_dict* dictionnary Dictionnary with the path of the parameter in hardware structure as key and the parameter name as element
========================== =========== ==========================================================================================================
See Also
--------
send_param_status, commit_settings
"""
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 Exception:
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 = pymodaq.daq_utils.parameter.utils.get_param_from_name(
self.settings, param.name())
if children is not None:
path = pymodaq.daq_utils.parameter.utils.get_param_path(
children)
self.settings.child(*path[1:-1]).removeChild(children)
self.settings.sigTreeStateChanged.connect(self.send_param_status)
self.commit_common_settings(param)
self.commit_settings(param)
def _getParameterTree(self):
params = [{u'name': unicode(self.tr(u'Envelope')), u'type': u'group',
u'children': [
{u'name':unicode(self.tr(u'Amplitude')), u'type':u'group', u'children':[
{u'name':unicode(self.tr(u'Min')), u'type':u'float', u'value': -100, u'step': 0.1, 'default': -100},
{u'name':unicode(self.tr(u'Max')), u'type':u'float', u'value': 100, u'step': 0.1, 'default': 100}
]}]}]
ListParameter.itemClass = DuettoListParameterItem
ParamTree = Parameter.create(name=u'params', type=u'group', children=params)
parameterTree = ParameterTree()
parameterTree.setAutoScroll(True)
parameterTree.setHeaderHidden(True)
parameterTree.setParameters(ParamTree, showTop=False)
return parameterTree
def setupTree():
params = [{
'name': 'Update Time (s)',
'type': 'float',
'value': 1
}, {
'name': 'std',
'type': 'float',
'value': 0
}, {
'name': 'Save Figure',
'type': 'action',
'visible': True
}]
p = Parameter.create(name='params', type='group', children=params)
t = ParameterTree()
t.setParameters(p, showTop=False)
return t, p
def setupTree():
params = [{
'name': 'Update Time (s)',
'type': 'float',
'value': 1
}, {
'name': 'Sample Name',
'type': 'int',
'value': 1
}, {
'name': 'Counter',
'type': 'int',
'value': 0
}]
p = Parameter.create(name='params', type='group', children=params)
t = ParameterTree()
t.setParameters(p, showTop=False)
return t, p
def XML_string_to_pobject(xml_string):
"""
return a Parameter object from its *translated* version as a XML string
Parameters
----------
xml_string: (str) string representation of a Parameter Object
Returns
-------
Parameter
See Also
--------
parameter_to_xml_string
"""
return Parameter.create(name='settings',
type='group',
children=XML_file_to_parameter(xml_string))
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 test_class_interact():
parent = Parameter.create(name="parent", type="group")
interactor = Interactor(parent=parent, nest=False)
class A:
def a(self, x=5):
return x
@classmethod
def b(cls, y=5):
return y
a = A()
ai = interactor.decorate()(a.a)
assert ai() == a.a()
bi = interactor.decorate()(A.b)
assert bi() == A.b()
def __init__(self):
ThresholdAdapter.__init__(self)
self.name = u'Double Threshold'
self.settings_parameter_list.insert(
1, {
u'name': unicode(self.tr(u'Threshold2 (dB)')),
u'type': u'float',
u'value': self.THRESHOLD2_DEFAULT,
u'step': 1,
u'limits': (-120, 0)
})
self.threshold2_dB = self.THRESHOLD2_DEFAULT
self.settings = Parameter.create(name=u'Settings',
type=u'group',
children=self.settings_parameter_list)
def __init__(self):
TimeLocationAdapter.__init__(self)
self.name = self.tr(u'Regular Duration')
self._settings.extend([{u'name': unicode(self.tr(u'duration (ms)')), u'type': u'int',
u'value': 100, u'step': 1, u'limits': (1, 100000)},
{u'name': unicode(self.tr(u'max intervals')), u'type': u'int',
u'value': 20, u'step': 1, u'limits': (1, 100000)}])
# the separation time between locations
self.duration_ms = 100
# the max amount of locations (the real amount of locations depends of the segment duration)
self.max_intervals = 20
self.settings = Parameter.create(name=u'Time Location', type=u'group', children=self._settings)
self.settings.sigTreeStateChanged.connect(lambda changes: self.dataChanged.emit())
def test_add_child():
p = Parameter.create(
name="test",
type="group",
children=[
dict(name="ch1", type="bool", value=True),
dict(name="ch2", type="bool", value=False),
],
)
with pytest.raises(ValueError):
p.addChild(dict(name="ch1", type="int", value=0))
existing = p.child("ch1")
ch = p.addChild(dict(name="ch1", type="int", value=0), existOk=True)
assert ch is existing
ch = p.addChild(dict(name="ch1", type="int", value=0),
autoIncrementName=True)
assert ch.name() == "ch3"
def __init__(self):
s = db.Session()
self._signalHandler = SignalHandler()
self.sigOutputChanged = self._signalHandler.sigOutputChanged
self.pairs = None
self.acsf = None
projects = s.query(db.Experiment.project_name).distinct().all()
project_list = [{'name': str(record[0]), 'type': 'bool'} for record in projects]
acsf = s.query(db.Experiment.acsf).distinct().all()
acsf_list = [{'name': str(record[0]), 'type': 'bool'} for record in acsf]
internal = s.query(db.Experiment.internal).distinct().all()
internal_list = [{'name': str(record[0]), 'type': 'bool'} for record in internal]
self.params = Parameter.create(name='Data Filters', type='group', children=[
{'name': 'Projects', 'type': 'group', 'children':project_list},
{'name': 'ACSF', 'type': 'group', 'children':acsf_list, 'expanded': False},
{'name': 'Internal', 'type': 'group', 'children': internal_list, 'expanded': False},
])
self.params.sigTreeStateChanged.connect(self.invalidate_output)
def __init__(self, targetModel, leakageFunction, showScriptParameter=None, parent=None):
super(CPAProgressive, self).__init__()
resultsParams = [{'name':'Iteration Mode', 'key':'itmode', 'type':'list', 'values':{'Depth-First':'df', 'Breadth-First':'bf'}, 'value':'bf'},
{'name':'Skip when PGE=0', 'key':'checkpge', 'type':'bool', 'value':False},
]
self.params = Parameter.create(name='Progressive CPA', type='group', children=resultsParams)
if showScriptParameter is not None:
self.showScriptParameter = showScriptParameter
# print self.showScriptParameter
ExtendedParameter.setupExtended(self.params, self)
self.model = targetModel
self.leakage = leakageFunction
self.sr = None
self.stats = DataTypeDiffs()
self.updateScript()
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.set_actuators(actuators, selected_actuators)
self.set_detectors(detectors, selected_detectors)
def __init__(self):
ClassifierAdapter.__init__(self)
db_session = DB().get_db_session()
self.name = u'KNN'
training_vector_count = db_session.query(Segment).filter(
or_(Segment.specie != None, Segment.genus != None,
Segment.family != None)).count()
if training_vector_count <= 10:
# from 10 to 50 steps of 5
start, stop, step, selected = 1, training_vector_count, 1, min(
training_vector_count, 10)
elif training_vector_count < 100:
# from 10 to 50 steps of 5
start, stop, step, selected = 10, min(training_vector_count,
50), 5, 10
elif training_vector_count < 1000:
# from 50 to 300 steps of 10
start, stop, step, selected = 50, min(training_vector_count,
300), 10, 50
else:
# from 200 to 500 steps of 20
start, stop, step, selected = 200, min(training_vector_count,
500), 20, 200
k_list = [(unicode(x), x) for x in xrange(start, stop, step)]
settings = [{
u'name': unicode(self.tr(u'K-Value')),
u'type': u'list',
u'default': selected,
u'values': k_list,
u'value': unicode(selected)
}]
self.k_value = selected
self.settings = Parameter.create(name=u'Settings',
type=u'group',
children=settings)
def addEventTypeParameterTree(self):
"""
For each perf event, add a parameter to parameter tree.
"""
children = []
events_type = [event.get_event_type() for event in self.events]
for event_type in set(events_type):
event_type_group = {
'type': 'group',
'name': event_type.get_name(),
'children': self.addEventsParameterTree(event_type)
}
children.append(event_type_group)
self.parameters = Parameter.create(name='params', type='group',
children=children)
self.parameters.sigTreeStateChanged.connect(self.treeChanged)
self.tree.setParameters(self.parameters, showTop=False)
self.hbox.addWidget(self.tree)
def addNew(self):
nextTime = 0.0
if self.hasChildren():
nextTime = self.children()[-1]['Proper Time'] + 1
self.addChild(
Parameter.create(name='Command',
autoIncrementName=True,
type=None,
renamable=True,
removable=True,
children=[
dict(name='Proper Time',
type='float',
value=nextTime),
dict(name='Acceleration',
type='float',
value=0.0,
step=0.1),
]))
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):
QtCore.QObject.__init__(self)
self.initParam()
## Create tree of Parameter objects
self.parameter = Parameter.create(name='OCR Parameter',
type='group',
children=self.params)
def turn2change(param, changes):
self.changeParam(param, changes)
self.parameter.sigTreeStateChanged.connect(turn2change)
self.tree = ParameterTree(None, showHeader=False)
self.tree.setParameters(self.parameter, showTop=True)
#Lazy Mode:
self.textList = None
self.ocrIndex = None
def __init__(self, fname, file_lock, parent=None):
"""fname: str, file path
file_lock: mp.Condition, process safe lock
"""
super().__init__(parent)
self.file_lock = file_lock
self.fname = fname
self.scan_name = 'null_thread'
self.parameters = Parameter.create(name='wrangler_widget',
type='int',
value=0)
self.sphere_args = {}
self.command_queue = Queue()
self.thread = wranglerThread(self.command_queue, self.sphere_args,
self.fname, self.file_lock, self)
self.thread.finished.connect(self.finished.emit)
self.thread.started.connect(self.started.emit)
self.thread.sigUpdate.connect(self.sigUpdateData.emit)
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 Exception:
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 = get_param_from_name(self.settings, param.name())
if children is not None:
path = 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(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.corrgraph = CorrelationVsTrace()
self.CorrelationOutputDock = QDockWidget(self.corrgraph.name)
self.CorrelationOutputDock.setObjectName(self.corrgraph.name)
self.CorrelationOutputDock.setAllowedAreas(Qt.BottomDockWidgetArea | Qt.RightDockWidgetArea| Qt.LeftDockWidgetArea)
self.CorrelationOutputDock.setWidget(self.corrgraph)
self.corrgraph.setDock(self.CorrelationOutputDock)
self.corrgraph.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 __init__(self, parent=None, params_state=None):
super(DAQ_Move_base, self).__init__()
self.move_is_done = False
self.parent = parent
self.controller = None
self.stage = None
self.status = edict(info="",
controller=None,
stage=None,
initialized=False)
self.current_position = 0
self.target_position = 0
self.settings = Parameter.create(name='Settings',
type='group',
children=self.params)
if params_state is not None:
self.settings.restoreState(params_state)
self.settings.sigTreeStateChanged.connect(self.send_param_status)
self.controller_units = self._controller_units
def setup_settings_layout(self):
settings_layout = QtGui.QGridLayout()
pobj = Parameter.create(name='params',
type='group',
children=self.param_config)
def on_param_change(param, changes):
for param, change, data in changes:
internal_name = param.opts['iname']
self.params[internal_name] = param.value()
pobj.sigTreeStateChanged.connect(on_param_change)
ptree = ParameterTree()
ptree.setParameters(pobj, showTop=False)
settings_layout.addWidget(ptree, 0, 0)
return settings_layout
def __init__(self):
TimeLocationAdapter.__init__(self)
self._settings.append({
u'name': unicode(self.tr(u'ms delay')),
u'type': u'int',
u'value': 0,
u'step': 1,
u'limits': (0, 60 * 60 * 1000)
})
# the time delay in ms of the time location
self.ms_delay = 0
self.settings = Parameter.create(name=u'Time Location',
type=u'group',
children=self._settings)
self.settings.sigTreeStateChanged.connect(
lambda changes: self.dataChanged.emit())
def __init__(self):
QtGui.QWidget.__init__(self)
self.setupGUI()
self.objectGroup = ShapefileGroup(self)
self.params = Parameter.create(name='ParmX',
type='group',
children=[
self.objectGroup,
dict(name='Build Citygml',
type='action'),
dict(name='Save Citygml',
type='action')
])
self.tree.setParameters(self.params, showTop=False)
self.params.param('Save Citygml').sigActivated.connect(
self.save_citygml)
self.params.param('Build Citygml').sigActivated.connect(
self.build_citygml)
def __init__(self, *args, **kwargs):
self.centerwidget = QtGui.QWidget()
self.fileslistwidget = widgets.filesListWidget()
self.centerwidget.setLayout(QtGui.QVBoxLayout())
self.centerwidget.layout().addWidget(self.fileslistwidget)
self.rightwidget = ParameterTree()
self.remeshOption = pTypes.SimpleParameter(type='bool',
name='GIXS remeshing',
value=False)
self.integrateOption = pTypes.SimpleParameter(
type='bool', name='Azimuthal integration', value=True)
self.roiOption = pTypes.SimpleParameter(type='bool',
name='Integrate last ROI',
value=True)
self.logOption = pTypes.SimpleParameter(type='bool',
name='Log scale image',
value=False)
self.cakeOption = pTypes.SimpleParameter(type='bool',
name='Cake (q/chi)',
value=False)
self.exportformat = pTypes.ListParameter(
type='list',
name='Image export format',
value=0,
values=['EDF (.edf)', 'TIFF (.tif)', 'JPEG (.jpg)'])
self.processButton = pTypes.ActionParameter(name='Process')
# self.abortButton = pTypes.ActionParameter(name='Abort')
params = [
self.remeshOption, self.cakeOption, self.integrateOption,
self.roiOption, self.logOption, self.exportformat,
self.processButton
]
paramgroup = Parameter.create(name='params',
type='group',
children=params)
self.rightwidget.setParameters(paramgroup, showTop=False)
self.processButton.sigActivated.connect(self.processfiles)
super(BatchPlugin, self).__init__(*args, **kwargs)
def __init__(self):
QtGui.QWidget.__init__(self)
self.setupGUI()
arg_list = self.retrieve_arg()
# arg_list = ['F:\\kianwee_work\\spyder_workspace\\solar_travel_gui\\solar_travel_gui\\stg_export_data.py',
# 'F:/kianwee_work/princeton/2020_01_to_2020_06/golfcart/model3d/solar_travel_data\\parking',
# 'F:/kianwee_work/princeton/2020_01_to_2020_06/golfcart/model3d/solar_travel_data\\travel']
self.arg_list = arg_list
self.parking_dir = arg_list[1]
self.travel_dir = arg_list[2]
self.export_range = dict(name='Export', type='group', expanded = True, title = "Export Data to CSV",
children=[dict(name='Start Date', type = 'group', expanded = True, title = "Specify Start Date",
children = [dict(name='Year:', type= 'list', values= [2019, 2020], value=2019),
dict(name='Month:', type= 'int', limits = (1,12), value = 9),
dict(name='Day:', type= 'int', limits = (1,31), value = 2),
dict(name='Hour:', type= 'int', limits = (0,23), value = 10)]),
dict(name='End Date', type = 'group', expanded = True, title = "Specify End Date",
children = [dict(name='Year:', type= 'list', values= [2019, 2020], value=2020),
dict(name='Month:', type= 'int', limits = (1,12), value = 9),
dict(name='Day:', type= 'int', limits = (1,31), value = 2),
dict(name='Hour:', type= 'int', limits = (0,23), value = 18)]),
dict(name='Data Range Loaded', type = 'str', readonly = True),
dict(name='Load Data Range', type = 'action'),
dict(name='Result File Chosen', type = 'str', readonly = True),
dict(name = 'Choose Result Path', type = 'action'),
dict(name = 'Export', type = 'action'),
dict(name='Progress', type = 'str', value ="", readonly = True, title = "Progress")]
)
self.params = Parameter.create(name='ParmX', type='group', children=[self.export_range])
self.tree.setParameters(self.params, showTop=False)
self.params.param('Export').param('Load Data Range').sigActivated.connect(self.load_export_data_range)
self.params.param('Export').param('Choose Result Path').sigActivated.connect(self.choose_filepath)
self.params.param('Export').param('Export').sigActivated.connect(self.export_data)
self.progress = 0
def __init__(self, name, parameter, *args, **kwargs):
"""Constructor
Arguments:
parameter (dict): (nested) dictionary of parameter uased with ClearMap routine
*args, **kwargs: parameter of constructor for ParameterTree
"""
super(ParameterWidget, self).__init__(*args, **kwargs)
self.parameterDict = parameter
#generate widget
params = dictToTree(parameter)
self.paramSet = Parameter.create(name=name,
type='group',
children=params)
self.setParameters(self.paramSet, showTop=False)
registerCallback(self, self.updateParameter)
