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)