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