def __init__(self): super(calibrationpanel, self).__init__() self.autoCalibrateAction = pTypes.ActionParameter( name='Auto Calibrate') self.autoCalibrateAction.sigActivated.connect(self.calibrate) calibrants = sorted(calibrant.ALL_CALIBRANTS.all.keys()) self.calibrant = pTypes.ListParameter(name='Calibrant Material', values=calibrants) self.autoCalibrateMethod = pTypes.ListParameter(name='Algorithm', values=self.algorithms) self.overlayAction = pTypes.ActionParameter(name='Simulate Calibrant') self.overlayAction.sigActivated.connect(self.simulatecalibrant) self.setParameters(pTypes.GroupParameter(name='Calibration', children=[ self.autoCalibrateAction, self.calibrant, self.autoCalibrateMethod, self.overlayAction ]), showTop=False)
def __init__(self, source_node, **kwargs): self._source_node = source_node name = repr(source_node) super().__init__(name=name) labels = [self.SOURCE_TYPE_PLACEHOLDER] + [ label for label in self.SOURCE_OPTIONS ] source_type_combo = parameterTypes.ListParameter( name=self.SOURCE_TYPE_COMBO_NAME, values=labels, value=labels[0] ) source_type_combo.sigValueChanged.connect(self._on_source_type_changed) self.source_type_combo = self.addChild(source_type_combo) if source_node is not None: for source_option, classes in self.SOURCE_OPTIONS.items(): if isinstance(source_node, classes.node_class): self.source_type_combo.setValue(source_option) controls = classes.controls_class( source_node=self._source_node, name=self.SOURCE_CONTROLS_NAME, ) self.source_controls = self.addChild(controls)
def __init__(self, headermodel: QStandardItemModel, selectionmodel: QItemSelectionModel): super(CalibrationPanel, self).__init__() self.selectionmodel = selectionmodel self.headermodel = headermodel self.header().close() calibrants = dict( zip(calibrant.ALL_CALIBRANTS.keys(), calibrant.ALL_CALIBRANTS.values())) self.device = pTypes.ListParameter(name='Device', type='list', values=[], value='') self.calibrant = pTypes.ListParameter(name='Calibrant Material', values=calibrants, value=calibrants['AgBh']) self.autoCalibrateMethod = pTypes.ListParameter( name='Algorithm', values=self.algorithms.keys()) self.autoCalibrateAction = pTypes.ActionParameter( name='Auto Calibrate') self.autoCalibrateAction.sigActivated.connect(self.calibrate) self.calibratetext = pTypes.TextParameter(name='Instructions', value='', readonly=True, visible=False) self.parameter = pTypes.GroupParameter(name='Calibration', children=[ self.device, self.calibrant, self.autoCalibrateMethod, self.autoCalibrateAction, self.autoCalibrateAction, self.calibratetext ]) self.setParameters(self.parameter, showTop=False) from xicam.core.execution import Workflow self.workflow = Workflow()
def __init__(self): super(calibrationpanel, self).__init__() self.autoCalibrateAction = pTypes.ActionParameter( name='Auto Calibrate') self.autoCalibrateAction.sigActivated.connect(self.calibrate) calibrants = sorted(calibrant.calibrant_factory().all.keys()) self.calibrant = pTypes.ListParameter(name='Calibrant Material', values=calibrants) self.autoCalibrateMethod = pTypes.ListParameter( name='Algorithm', values=self.algorithms.keys()) self.setParameters(pTypes.GroupParameter(name='Calibration', children=[ self.autoCalibrateAction, self.calibrant, self.autoCalibrateMethod ]), showTop=False)
def __init__(self, pipeline: Pipeline, **kwargs): self._pipeline = pipeline super().__init__(**kwargs) labels = [self.SOURCE_TYPE_PLACEHOLDER] + [label for label in self.SOURCE_OPTIONS] source_type_combo = parameterTypes.ListParameter(name=self.SOURCE_TYPE_COMBO_NAME, values=labels, value=labels[0]) source_type_combo.sigValueChanged.connect(self._on_source_type_changed) self.source_type_combo = self.addChild(source_type_combo) if pipeline.source is not None: for source_option, classes in self.SOURCE_OPTIONS.items(): if isinstance(pipeline.source, classes.node_class): self.source_type_combo.setValue(source_option)
def __init__(self, pipeline, **kwargs): kwargs['title'] = 'LSL stream' super().__init__(pipeline, **kwargs) stream_names = [info.name() for info in pylsl.resolve_streams()] values = [self.STREAM_NAME_PLACEHOLDER] + stream_names try: value = self.source_node.stream_name except AttributeError: value = self.STREAM_NAME_PLACEHOLDER stream_names_combo = parameterTypes.ListParameter( name=self.STREAM_NAMES_COMBO_NAME, values=values, value=value) stream_names_combo.sigValueChanged.connect(self._on_stream_name_picked) self.stream_names_combo = self.addChild(stream_names_combo)
def __init__(self, name, project, datatype_name, values, context, model_parent, typecheck=True, **kwargs): """ Initializes the Structure Parameter class. Parameters: ----------- name : str The name of the parameter project : pymap.project.Project The underlying pymap project. datatype_name : str The name of the datatype associated with the parameter. values : list The values of the array. context : list The context. model_parent : parameterTypes.Parameter The parent of the parameter according to the data model. """ self.datatype = project.model[datatype_name] self.project = project self.context = context self.model_parent = model_parent super().__init__(name=name, **kwargs) # Add the list that enbales navigating through the array size = self.size_get() self.addChild( parameterTypes.ListParameter(name='idx', title='Index', values=list(range(size)), value=None, default=None)) # Create one parameter for each value self.values = [] for idx, value in enumerate(values): self._insert(idx, value=value) self.update_value()
def __init__(self, model, plot, **kwargs): kwargs['type'] = 'group' kwargs['name'] = 'Scene' self.plot = plot self.parameters = { 'min value': lambda plot: num.nanmin(plot.data), 'max value': lambda plot: num.nanmax(plot.data), 'mean value': lambda plot: num.nanmean(plot.data), } self.plot.image.sigImageChanged.connect(self.updateValues) KiteParameterGroup.__init__(self, model=self.plot, model_attr=None, **kwargs) def changeComponent(parameter): self.plot.component = parameter.value() p = { 'name': 'display', 'values': { 'displacement': 'displacement', 'theta': 'theta', 'phi': 'phi', 'thetaDeg': 'thetaDeg', 'phiDeg': 'phiDeg', 'los.unitE': 'unitE', 'los.unitN': 'unitN', 'los.unitU': 'unitU', }, 'value': 'displacement', 'tip': 'Change the displayed component of the displacement field.' } if model.scene.displacement_px_var is not None: p['values']['displacement_px_var'] = 'displacement_px_var' component = pTypes.ListParameter(**p) component.sigValueChanged.connect(changeComponent) self.pushChild(component)
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, model, plot, **kwargs): kwargs["type"] = "group" kwargs["name"] = "Scene" self.plot = plot self.parameters = { "min value": lambda plot: num.nanmin(plot.data), "max value": lambda plot: num.nanmax(plot.data), "mean value": lambda plot: num.nanmean(plot.data), } self.plot.image.sigImageChanged.connect(self.updateValues) KiteParameterGroup.__init__(self, model=self.plot, model_attr=None, **kwargs) def changeComponent(parameter): self.plot.component = parameter.value() p = { "name": "display", "values": { "displacement": "displacement", "theta": "theta", "phi": "phi", "thetaDeg": "thetaDeg", "phiDeg": "phiDeg", "los.unitE": "unitE", "los.unitN": "unitN", "los.unitU": "unitU", }, "value": "displacement", "tip": "Change the displayed component of the displacement field.", } if model.scene.displacement_px_var is not None: p["values"]["displacement_px_var"] = "displacement_px_var" component = pTypes.ListParameter(**p) component.sigValueChanged.connect(changeComponent) self.pushChild(component)
def __init__(self, model, plot, *args, **kwargs): self.plot = plot self.sig_guard = True self.sp = model kwargs['type'] = 'group' kwargs['name'] = 'Scene.quadtree' self.parameters = OrderedDict([ ('nleaves', None), ('reduction_rms', None), ('reduction_efficiency', None), ('epsilon_min', None), ('nnodes', None), ]) KiteParameterGroup.__init__(self, model=model, model_attr='quadtree', **kwargs) model.sigQuadtreeConfigChanged.connect(self.onConfigUpdate) model.sigQuadtreeChanged.connect(self.updateValues) self.sigEpsilon.connect(model.qtproxy.setEpsilon) self.sigNanFraction.connect(model.qtproxy.setNanFraction) self.sigTileMaximum.connect(model.qtproxy.setTileMaximum) self.sigTileMinimum.connect(model.qtproxy.setTileMinimum) def updateGuard(func): def wrapper(*args, **kwargs): if not self.sig_guard: func() return wrapper # Epsilon control @updateGuard def updateEpsilon(): self.sigEpsilon.emit(self.epsilon.value()) p = { 'name': 'epsilon', 'value': model.quadtree.epsilon, 'type': 'float', 'default': model.quadtree._epsilon_init, 'step': round((model.quadtree.epsilon - model.quadtree.epsilon_min) * .1, 3), 'limits': (model.quadtree.epsilon_min, 3 * model.quadtree._epsilon_init), 'editable': True } self.epsilon = pTypes.SimpleParameter(**p) self.epsilon.itemClass = SliderWidgetParameterItem self.epsilon.sigValueChanged.connect(updateEpsilon) # Epsilon control @updateGuard def updateNanFrac(): self.sigNanFraction.emit(self.nan_allowed.value()) p = { 'name': 'nan_allowed', 'value': model.quadtree.nan_allowed, 'default': QuadtreeConfig.nan_allowed.default(), 'type': 'float', 'step': 0.05, 'limits': (0., 1.), 'editable': True, } self.nan_allowed = pTypes.SimpleParameter(**p) self.nan_allowed.itemClass = SliderWidgetParameterItem self.nan_allowed.sigValueChanged.connect(updateNanFrac) # Tile size controls @updateGuard def updateTileSizeMin(): self.sigTileMinimum.emit(self.tile_size_min.value()) p = { 'name': 'tile_size_min', 'value': model.quadtree.tile_size_min, 'default': QuadtreeConfig.tile_size_min.default(), 'type': 'int', 'limits': (50, 50000), 'step': 100, 'editable': True, 'suffix': 'm' } self.tile_size_min = pTypes.SimpleParameter(**p) self.tile_size_min.itemClass = SliderWidgetParameterItem @updateGuard def updateTileSizeMax(): self.sigTileMaximum.emit(self.tile_size_max.value()) p.update({ 'name': 'tile_size_max', 'value': model.quadtree.tile_size_max, 'default': QuadtreeConfig.tile_size_max.default() }) self.tile_size_max = pTypes.SimpleParameter(**p) self.tile_size_max.itemClass = SliderWidgetParameterItem self.tile_size_min.sigValueChanged.connect(updateTileSizeMin) self.tile_size_max.sigValueChanged.connect(updateTileSizeMax) # Component control def changeComponent(): self.plot.component = self.components.value() p = { 'name': 'display', 'values': { 'QuadNode.mean': 'mean', 'QuadNode.median': 'median', 'QuadNode.weight': 'weight', }, 'value': 'mean' } self.components = pTypes.ListParameter(**p) self.components.sigValueChanged.connect(changeComponent) def changeCorrection(): model.quadtree.setCorrection(correction_method.value()) self.updateEpsilonLimits() p = { 'name': 'setCorrection', 'values': { 'Mean (Jonsson, 2002)': 'mean', 'Median (Jonsson, 2002)': 'median', 'Bilinear (Jonsson, 2002)': 'bilinear', 'SD (Jonsson, 2002)': 'std', }, 'value': QuadtreeConfig.correction.default() } correction_method = pTypes.ListParameter(**p) correction_method.sigValueChanged.connect(changeCorrection) self.sig_guard = False self.pushChild(correction_method) self.pushChild(self.tile_size_max) self.pushChild(self.tile_size_min) self.pushChild(self.nan_allowed) self.pushChild(self.epsilon) self.pushChild(self.components)
def __init__(self, model, **kwargs): kwargs['type'] = 'group' kwargs['name'] = 'Scene.covariance' self.sp = model self.parameters = OrderedDict([ ('variance', None), ('covariance_model', lambda c: ', '.join('%g' % p for p in c.covariance_model)), ('covariance_model_rms', None), ('noise_patch_size_km2', None), ('noise_patch_coord', lambda c: ', '.join([str(f) for f in c.noise_coord.tolist()])), ]) model.sigCovarianceChanged.connect(self.updateValues) KiteParameterGroup.__init__(self, model=model, model_attr='covariance', **kwargs) def changeSamplingMethod(): model.covariance.setSamplingMethod(sampling_method.value()) p = { 'name': 'sampling_method', 'values': { 'spatial random': 'spatial', 'spectral': 'spectral', }, 'value': model.covariance.config.sampling_method, 'tip': CovarianceConfig.sampling_method.help, } sampling_method = pTypes.ListParameter(**p) sampling_method.sigValueChanged.connect(changeSamplingMethod) def changeSpatialBins(): model.covariance.setSpatialBins(spatial_bins.value()) p = { 'name': 'spatial_bins', 'value': model.covariance.config.spatial_bins, 'type': 'int', 'limits': (25, 500), 'step': 5, 'edditable': True, 'tip': CovarianceConfig.spatial_bins.help } spatial_bins = pTypes.SimpleParameter(**p) spatial_bins.sigValueChanged.connect(changeSpatialBins) def changeSpatialPairs(): model.covariance.setSpatialPairs(spatial_pairs.value()) p = { 'name': 'spatial_pairs', 'value': model.covariance.config.spatial_pairs, 'type': 'int', 'limits': (0, 1000000), 'step': 50000, 'edditable': True, 'tip': CovarianceConfig.spatial_pairs.help } spatial_pairs = pTypes.SimpleParameter(**p) spatial_pairs.sigValueChanged.connect(changeSpatialPairs) def changeModelFunction(): model.covariance.setModelFunction(model_function.value()) p = { 'name': 'model_function', 'values': { 'exponential': 'exponential', 'exp + cosine': 'exponential_cosine', }, 'value': model.covariance.config.model_function, 'tip': CovarianceConfig.model_function.help } model_function = pTypes.ListParameter(**p) model_function.sigValueChanged.connect(changeModelFunction) self.pushChild(model_function) self.pushChild(spatial_bins) self.pushChild(spatial_pairs) self.pushChild(sampling_method)
def __init__(self, model, **kwargs): kwargs["type"] = "group" kwargs["name"] = "Scene.covariance" self.sp = model self.parameters = OrderedDict([ ("variance", None), ( "covariance_model", lambda c: ", ".join("%g" % p for p in c.covariance_model), ), ("covariance_model_rms", None), ("noise_patch_size_km2", None), ( "noise_patch_coord", lambda c: ", ".join( ["%.2f" % f for f in c.noise_coord.tolist()]), ), ]) model.sigCovarianceChanged.connect(self.updateValues) KiteParameterGroup.__init__(self, model=model, model_attr="covariance", **kwargs) def changeSamplingMethod(): model.covariance.setSamplingMethod(sampling_method.value()) p = { "name": "sampling_method", "values": { "spatial random": "spatial", "spectral": "spectral", }, "value": model.covariance.config.sampling_method, "tip": CovarianceConfig.sampling_method.help, } sampling_method = pTypes.ListParameter(**p) sampling_method.sigValueChanged.connect(changeSamplingMethod) def changeSpatialBins(): model.covariance.setSpatialBins(spatial_bins.value()) p = { "name": "spatial_bins", "value": model.covariance.config.spatial_bins, "type": "int", "limits": (1, 500), "step": 5, "edditable": True, "tip": CovarianceConfig.spatial_bins.help, } spatial_bins = pTypes.SimpleParameter(**p) spatial_bins.sigValueChanged.connect(changeSpatialBins) def changeSpatialPairs(): model.covariance.setSpatialPairs(spatial_pairs.value()) p = { "name": "spatial_pairs", "value": model.covariance.config.spatial_pairs, "type": "int", "limits": (1, 1000000), "step": 50000, "edditable": True, "tip": CovarianceConfig.spatial_pairs.help, } spatial_pairs = pTypes.SimpleParameter(**p) spatial_pairs.sigValueChanged.connect(changeSpatialPairs) def changeModelFunction(): model.covariance.setModelFunction(model_function.value()) p = { "name": "model_function", "values": { "exponential": "exponential", "exp + cosine": "exponential_cosine", }, "value": model.covariance.config.model_function, "tip": CovarianceConfig.model_function.help, } model_function = pTypes.ListParameter(**p) model_function.sigValueChanged.connect(changeModelFunction) def toggle_adaptive_subsampling(param, checked): model.covariance.config.adaptive_subsampling = checked p = { "name": "adaptive_subsampling", "type": "bool", "value": model.covariance.config.adaptive_subsampling, "tip": "detrend the scene", } adaptive_subsampling = pTypes.SimpleParameter(**p) adaptive_subsampling.sigValueChanged.connect( toggle_adaptive_subsampling) self.pushChild(adaptive_subsampling) self.pushChild(model_function) self.pushChild(spatial_bins) self.pushChild(spatial_pairs) self.pushChild(sampling_method)
def __init__(self, model, plot, *args, **kwargs): self.plot = plot self.sig_guard = True self.sp = model kwargs['type'] = 'group' kwargs['name'] = 'Scene.quadtree' self.parameters = OrderedDict( [('nleaves', None), ('reduction_rms', None), ('reduction_efficiency', None), ('epsilon_min', None), ('nnodes', None), ]) KiteParameterGroup.__init__( self, model=model, model_attr='quadtree', **kwargs) model.sigQuadtreeConfigChanged.connect(self.onConfigUpdate) model.sigQuadtreeChanged.connect(self.updateValues) self.sigEpsilon.connect(model.qtproxy.setEpsilon) self.sigNanFraction.connect(model.qtproxy.setNanFraction) self.sigTileMaximum.connect(model.qtproxy.setTileMaximum) self.sigTileMinimum.connect(model.qtproxy.setTileMinimum) def updateGuard(func): def wrapper(*args, **kwargs): if not self.sig_guard: func() return wrapper # Epsilon control @updateGuard @QtCore.pyqtSlot() def updateEpsilon(): self.sigEpsilon.emit(self.epsilon.value()) eps_decimals = -math.floor(math.log10(model.quadtree.epsilon_min)) eps_steps = round((model.quadtree.epsilon - model.quadtree.epsilon_min)*.1, 3) p = { 'name': 'epsilon', 'type': 'float', 'value': model.quadtree.epsilon, 'default': model.quadtree._epsilon_init, 'step': eps_steps, 'limits': (model.quadtree.epsilon_min, 3*model.quadtree._epsilon_init), 'editable': True, 'decimals': eps_decimals, 'slider_exponent': 2, 'tip': QuadtreeConfig.epsilon.help } self.epsilon = pTypes.SimpleParameter(**p) self.epsilon.itemClass = SliderWidgetParameterItem self.epsilon.sigValueChanged.connect(updateEpsilon) @updateGuard @QtCore.pyqtSlot() def updateNanFrac(): self.sigNanFraction.emit(self.nan_allowed.value()) p = { 'name': 'nan_allowed', 'type': 'float', 'value': model.quadtree.nan_allowed, 'default': QuadtreeConfig.nan_allowed.default(), 'step': 0.05, 'limits': (0., 1.), 'editable': True, 'decimals': 2, 'tip': QuadtreeConfig.nan_allowed.help } self.nan_allowed = pTypes.SimpleParameter(**p) self.nan_allowed.itemClass = SliderWidgetParameterItem self.nan_allowed.sigValueChanged.connect(updateNanFrac) # Tile size controls @updateGuard @QtCore.pyqtSlot() def updateTileSizeMin(): self.sigTileMinimum.emit(self.tile_size_min.value()) frame = model.frame max_px = max(frame.shape) max_pxd = max(frame.dE, frame.dN) limits = (max_pxd * model.quadtree.min_node_length_px, max_pxd * (max_px / 4)) tile_decimals = -math.floor(math.log10(model.quadtree.tile_size_min)) p = {'name': 'tile_size_min', 'type': 'float', 'value': model.quadtree.tile_size_min, 'default': QuadtreeConfig.tile_size_min.default(), 'limits': limits, 'step': 250, 'slider_exponent': 2, 'editable': True, 'suffix': ' m' if frame.isMeter() else ' deg', 'decimals': 0 if frame.isMeter() else tile_decimals, 'tip': QuadtreeConfig.tile_size_min.help } self.tile_size_min = pTypes.SimpleParameter(**p) self.tile_size_min.itemClass = SliderWidgetParameterItem @updateGuard def updateTileSizeMax(): self.sigTileMaximum.emit(self.tile_size_max.value()) p.update({'name': 'tile_size_max', 'value': model.quadtree.tile_size_max, 'default': QuadtreeConfig.tile_size_max.default(), 'tip': QuadtreeConfig.tile_size_max.help }) self.tile_size_max = pTypes.SimpleParameter(**p) self.tile_size_max.itemClass = SliderWidgetParameterItem self.tile_size_min.sigValueChanged.connect(updateTileSizeMin) self.tile_size_max.sigValueChanged.connect(updateTileSizeMax) # Component control @QtCore.pyqtSlot() def changeComponent(): self.plot.component = self.components.value() p = {'name': 'display', 'values': { 'QuadNode.mean': 'mean', 'QuadNode.median': 'median', 'QuadNode.weight': 'weight', }, 'value': 'mean', 'tip': 'Change displayed component' } self.components = pTypes.ListParameter(**p) self.components.sigValueChanged.connect(changeComponent) @QtCore.pyqtSlot() def changeCorrection(): model.quadtree.setCorrection(correction_method.value()) self.updateEpsilonLimits() p = {'name': 'setCorrection', 'values': { 'Mean (Jonsson, 2002)': 'mean', 'Median (Jonsson, 2002)': 'median', 'Bilinear (Jonsson, 2002)': 'bilinear', 'SD (Jonsson, 2002)': 'std', }, 'value': model.quadtree.config.correction, 'tip': QuadtreeConfig.correction.help } correction_method = pTypes.ListParameter(**p) correction_method.sigValueChanged.connect(changeCorrection) self.sig_guard = False self.pushChild(correction_method) self.pushChild(self.tile_size_max) self.pushChild(self.tile_size_min) self.pushChild(self.nan_allowed) self.pushChild(self.epsilon) self.pushChild(self.components)
def _create_parameters(self): take_abs_bool = parameterTypes.SimpleParameter( type='bool', name=self.TAKE_ABS_BOOL_NAME, value=True, readonly=True) take_abs_bool.sigValueChanged.connect(self._on_take_abs_toggled) self.take_abs_bool = self.addChild(take_abs_bool) limits_modes = self.OUTPUT_CLASS.LIMITS_MODES limits_mode_values = [ limits_modes.LOCAL, limits_modes.GLOBAL, limits_modes.MANUAL ] limits_mode_value = self._output_node.limits_mode limits_mode_combo = parameterTypes.ListParameter( name=self.LIMITS_MODE_COMBO_NAME, values=limits_mode_values, value=limits_mode_value) limits_mode_combo.sigValueChanged.connect(self._on_limits_mode_changed) self.limits_mode_combo = self.addChild(limits_mode_combo) lock_limits_bool = parameterTypes.SimpleParameter( type='bool', name=self.LOCK_LIMITS_BOOL_NAME, value=False) lock_limits_bool.sigValueChanged.connect(self._on_lock_limits_toggled) self.lock_limits_bool = self.addChild(lock_limits_bool) buffer_length_value = self._output_node.buffer_length buffer_length_slider = SliderParameter( name=self.BUFFER_LENGTH_SLIDER_NAME, limits=(0.1, 10), value=buffer_length_value, prec=3, suffix=' s') buffer_length_slider.sigValueChanged.connect( self._on_buffer_length_changed) self.buffer_length_slider = self.addChild(buffer_length_slider) lower_limit_value = self._output_node.colormap_limits.lower upper_limit_value = self._output_node.colormap_limits.upper lower_limit_spinbox = parameterTypes.SimpleParameter( type='float', name=self.LOWER_LIMIT_SPIN_BOX_NAME, decimals=3, limits=(None, upper_limit_value)) upper_limit_spinbox = parameterTypes.SimpleParameter( type='float', name=self.UPPER_LIMIT_SPIN_BOX_NAME, decimals=3, limits=(lower_limit_value, None)) lower_limit_spinbox.sigValueChanged.connect( self._on_lower_limit_changed) upper_limit_spinbox.sigValueChanged.connect( self._on_upper_limit_changed) self.lower_limit_spinbox = self.addChild( lower_limit_spinbox) # type: parameterTypes.SimpleParameter self.upper_limit_spinbox = self.addChild( upper_limit_spinbox) # type: parameterTypes.SimpleParameter threshold_value = self._output_node.threshold_pct threshold_slider = SliderParameter(name=self.THRESHOLD_SLIDER_NAME, limits=(0, 99), value=threshold_value, prec=0, suffix='%') threshold_slider.sigValueChanged.connect(self._on_threshold_changed) self.threshold_slider = self.addChild(threshold_slider)
def __init__(self): super(spacegroupwidget, self).__init__() self.parameter = pTypes.GroupParameter(name='') self.setParameters(self.parameter, showTop=False) self.crystalsystem = pTypes.ListParameter(type='list', name='Crystal System', values=spacegrouptypes, value=None) self.spacegroupparameter = pTypes.ListParameter( type='list', name='Space Group', values=spacegroupnames[0], value=None) self.rotationstyle = pTypes.ListParameter(type='list', name='Rotation Mode', values=[ 'Sample-frame vector', 'Crystal-frame vector', 'Crystal plane' ]) self.rotationstyle.sigValueChanged.connect(self.rotationmodechanged) self.rotationxyz = VectorParameter(name='Vector (x,y,z)') self.rotationvectorsample = hideableGroup( name='Rotation (sample-frame vector)', children=[self.rotationxyz]) self.rotationxyz.setValue([0, 0, 1]) self.rotationuvw = VectorParameter(name='Vector (u,v,w)') self.rotationvectorcrystal = hideableGroup( name='Rotation (crystal-frame vector)', children=[self.rotationuvw]) self.rotationuvw.setValue([0, 0, 1]) self.rotationhkl = VectorParameter(name='Vector (h,k,l)') self.rotationplane = hideableGroup(name='Rotation (crystal plane)', children=[self.rotationhkl]) self.rotationhkl.setValue([0, 0, 1]) self.spacegroupeditors = [ triclinicparameter(), monoclinicparameter(), orthorhombicparameter(), tetragonalparameter(), trigonalparameter(), hexagonalparameter(), cubicparameter() ] self.rotations = [ self.rotationvectorsample, self.rotationvectorcrystal, self.rotationplane ] self.delta = pTypes.SimpleParameter(name=u'δ', type='float', value=2.67150153E-06) self.beta = pTypes.SimpleParameter(name=u'β', type='float', value=3.71373554E-09) self.refractiveindex = pTypes.GroupParameter( name='Refractive Index', children=[self.delta, self.beta]) self.redrawsg = pTypes.ActionParameter(name='Overlay space group') self.redrawsg.sigActivated.connect(self.drawoverlay) self.parameter.addChildren( [self.crystalsystem, self.spacegroupparameter] + self.spacegroupeditors + [self.rotationstyle] + self.rotations + [self.refractiveindex, self.redrawsg]) self.hidechildren() self.hiderotations() self.parameter.children()[2].show() self.rotations[0].show() self.crystalsystem.sigValueChanged.connect(self.crystalsystemchanged)
def _create_parameters(self): take_abs_bool = parameterTypes.SimpleParameter( type="bool", name=self.TAKE_ABS_BOOL_NAME, value=True, readonly=True, ) take_abs_bool.sigValueChanged.connect(self._on_take_abs_toggled) self.take_abs_bool = self.addChild(take_abs_bool) limits_modes = self.OUTPUT_CLASS.LIMITS_MODES limits_mode_values = [ limits_modes.LOCAL, limits_modes.GLOBAL, limits_modes.MANUAL, ] limits_mode_value = self._output_node.limits_mode limits_mode_combo = parameterTypes.ListParameter( name=self.LIMITS_MODE_COMBO_NAME, values=limits_mode_values, value=limits_mode_value, ) limits_mode_combo.sigValueChanged.connect(self._on_limits_mode_changed) self.limits_mode_combo = self.addChild(limits_mode_combo) lock_limits_bool = parameterTypes.SimpleParameter( type="bool", name=self.LOCK_LIMITS_BOOL_NAME, value=False) lock_limits_bool.sigValueChanged.connect(self._on_lock_limits_toggled) self.lock_limits_bool = self.addChild(lock_limits_bool) buffer_length_value = self._output_node.buffer_length buffer_length_slider = SliderParameter( name=self.BUFFER_LENGTH_SLIDER_NAME, limits=(0.1, 10), value=buffer_length_value, prec=3, suffix=" s", ) buffer_length_slider.sigValueChanged.connect( self._on_buffer_length_changed) self.buffer_length_slider = self.addChild(buffer_length_slider) lower_limit_value = self._output_node.colormap_limits.lower upper_limit_value = self._output_node.colormap_limits.upper lower_limit_spinbox = parameterTypes.SimpleParameter( type="float", name=self.LOWER_LIMIT_SPIN_BOX_NAME, decimals=3, limits=(None, upper_limit_value), ) upper_limit_spinbox = parameterTypes.SimpleParameter( type="float", name=self.UPPER_LIMIT_SPIN_BOX_NAME, decimals=3, limits=(lower_limit_value, None), ) lower_limit_spinbox.sigValueChanged.connect( self._on_lower_limit_changed) upper_limit_spinbox.sigValueChanged.connect( self._on_upper_limit_changed) self.lower_limit_spinbox = self.addChild(lower_limit_spinbox) self.upper_limit_spinbox = self.addChild(upper_limit_spinbox) self._on_limits_mode_changed(None, limits_mode_value) threshold_value = self._output_node.threshold_pct threshold_slider = SliderParameter( name=self.THRESHOLD_SLIDER_NAME, limits=(0, 99), value=threshold_value, prec=0, suffix="%", ) threshold_slider.sigValueChanged.connect(self._on_threshold_changed) self.threshold_slider = self.addChild(threshold_slider) gif_button = parameterTypes.ActionParameter(type="action", name="Record gif") gif_button.sigActivated.connect(self._toggle_gif_button) self.gif_button = self.addChild(gif_button) fps_text = parameterTypes.TextParameter(name="Refresh rate, FPS", readonly=True, value="0.0") self.fps_text = self.addChild(fps_text)
def __init__(self, model, **kwargs): from datetime import datetime as dt kwargs['type'] = 'group' kwargs['name'] = '.meta' def str_to_time(d, fmt='%Y-%m-%d %H:%M:%S'): return dt.strftime(dt.fromtimestamp(d), fmt) self.parameters = OrderedDict([ ('time_master', lambda sc: str_to_time(sc.meta.time_master)), ('time_slave', lambda sc: str_to_time(sc.meta.time_slave)), ('time_separation', lambda sc: '%s' % sc.meta.time_separation), ]) model.sigConfigChanged.connect(self.updateValues) KiteParameterGroup.__init__(self, model=model, model_attr='scene', **kwargs) def update_meta_info(key, value): self.model.scene.meta.__setattr__(key, value) p = {'name': 'scene_title', 'value': self.model.scene.meta.scene_title, 'type': 'str', 'tip': 'Title of the displacement scene' } self.scene_title = pTypes.SimpleParameter(**p) self.scene_title.sigValueChanged.connect( lambda v: update_meta_info('scene_title', v.value())) p = {'name': 'scene_id', 'value': self.model.scene.meta.scene_id, 'type': 'str' } self.scene_id = pTypes.SimpleParameter(**p) self.scene_id.sigValueChanged.connect( lambda v: update_meta_info('scene_id', v.value())) p = {'name': 'satellite_name', 'value': self.model.scene.meta.satellite_name, 'type': 'str', 'tip': 'Name of the satellite' } self.satellite_name = pTypes.SimpleParameter(**p) self.satellite_name.sigValueChanged.connect( lambda v: update_meta_info('satellite_name', v.value())) p = {'name': 'orbital_node', 'values': { 'Ascending': 'Ascending', 'Descending': 'Descending', 'Undefined': 'Undefined', }, 'value': self.model.scene.meta.orbital_node, 'tip': 'Satellite orbit direction' } self.orbital_node = pTypes.ListParameter(**p) self.orbital_node.sigValueChanged.connect( lambda v: update_meta_info('orbital_node', v.value())) self.pushChild(self.orbital_node) self.pushChild(self.satellite_name) self.pushChild(self.scene_id) self.pushChild(self.scene_title)
def __init__(self, model, **kwargs): from datetime import datetime as dt kwargs["type"] = "group" kwargs["name"] = ".meta" def str_to_time(d, fmt="%Y-%m-%d %H:%M:%S"): return dt.strftime(dt.fromtimestamp(d), fmt) self.parameters = OrderedDict( [ ("time_master", lambda sc: str_to_time(sc.meta.time_master)), ("time_slave", lambda sc: str_to_time(sc.meta.time_slave)), ("time_separation", lambda sc: "%s" % sc.meta.time_separation), ] ) model.sigConfigChanged.connect(self.updateValues) KiteParameterGroup.__init__(self, model=model, model_attr="scene", **kwargs) def update_meta_info(key, value): self.model.scene.meta.__setattr__(key, value) p = { "name": "scene_title", "value": self.model.scene.meta.scene_title, "type": "str", "tip": "Title of the displacement scene", } self.scene_title = pTypes.SimpleParameter(**p) self.scene_title.sigValueChanged.connect( lambda v: update_meta_info("scene_title", v.value()) ) p = {"name": "scene_id", "value": self.model.scene.meta.scene_id, "type": "str"} self.scene_id = pTypes.SimpleParameter(**p) self.scene_id.sigValueChanged.connect( lambda v: update_meta_info("scene_id", v.value()) ) p = { "name": "satellite_name", "value": self.model.scene.meta.satellite_name, "type": "str", "tip": "Name of the satellite", } self.satellite_name = pTypes.SimpleParameter(**p) self.satellite_name.sigValueChanged.connect( lambda v: update_meta_info("satellite_name", v.value()) ) p = { "name": "orbital_node", "values": { "Ascending": "Ascending", "Descending": "Descending", "Undefined": "Undefined", }, "value": self.model.scene.meta.orbital_node, "tip": "Satellite orbit direction", } self.orbital_node = pTypes.ListParameter(**p) self.orbital_node.sigValueChanged.connect( lambda v: update_meta_info("orbital_node", v.value()) ) self.pushChild(self.orbital_node) self.pushChild(self.satellite_name) self.pushChild(self.scene_id) self.pushChild(self.scene_title)
def __init__(self, model, plot, *args, **kwargs): self.plot = plot self.sig_guard = True self.sp = model kwargs["type"] = "group" kwargs["name"] = "Scene.quadtree" self.parameters = OrderedDict( [ ("nleaves", None), ("reduction_rms", None), # ('reduction_efficiency', None), # ('epsilon_min', None), ("nnodes", None), ] ) KiteParameterGroup.__init__(self, model=model, model_attr="quadtree", **kwargs) model.sigQuadtreeConfigChanged.connect(self.onConfigUpdate) model.sigQuadtreeChanged.connect(self.updateValues) self.sigEpsilon.connect(model.qtproxy.setEpsilon) self.sigNanFraction.connect(model.qtproxy.setNanFraction) self.sigTileMaximum.connect(model.qtproxy.setTileMaximum) self.sigTileMinimum.connect(model.qtproxy.setTileMinimum) def updateGuard(func): def wrapper(*args, **kwargs): if not self.sig_guard: func() return wrapper # Epsilon control @updateGuard @QtCore.pyqtSlot() def updateEpsilon(): self.sigEpsilon.emit(self.epsilon.value()) eps_decimals = -math.floor(math.log10(model.quadtree.epsilon_min or 1e-3)) eps_steps = round( (model.quadtree.epsilon - model.quadtree.epsilon_min) * 0.1, 3 ) p = { "name": "epsilon", "type": "float", "value": model.quadtree.epsilon, "default": model.quadtree._epsilon_init, "step": eps_steps, "limits": (model.quadtree.epsilon_min, 3 * model.quadtree._epsilon_init), "editable": True, "decimals": eps_decimals, "slider_exponent": 2, "tip": QuadtreeConfig.epsilon.help, } self.epsilon = pTypes.SimpleParameter(**p) self.epsilon.itemClass = SliderWidgetParameterItem self.epsilon.sigValueChanged.connect(updateEpsilon) @updateGuard @QtCore.pyqtSlot() def updateNanFrac(): self.sigNanFraction.emit(self.nan_allowed.value()) p = { "name": "nan_allowed", "type": "float", "value": model.quadtree.nan_allowed, "default": QuadtreeConfig.nan_allowed.default(), "step": 0.05, "limits": (0.0, 1.0), "editable": True, "decimals": 2, "tip": QuadtreeConfig.nan_allowed.help, } self.nan_allowed = pTypes.SimpleParameter(**p) self.nan_allowed.itemClass = SliderWidgetParameterItem self.nan_allowed.sigValueChanged.connect(updateNanFrac) # Tile size controls @updateGuard @QtCore.pyqtSlot() def updateTileSizeMin(): self.sigTileMinimum.emit(self.tile_size_min.value()) frame = model.frame max_px = max(frame.shape) max_pxd = max(frame.dE, frame.dN) limits = (max_pxd * model.quadtree.min_node_length_px, max_pxd * (max_px / 4)) tile_decimals = 2 p = { "name": "tile_size_min", "type": "float", "value": model.quadtree.tile_size_min, "default": QuadtreeConfig.tile_size_min.default(), "limits": limits, "step": 250, "slider_exponent": 2, "editable": True, "suffix": " m" if frame.isMeter() else "°", "decimals": 0 if frame.isMeter() else tile_decimals, "tip": QuadtreeConfig.tile_size_min.help, } self.tile_size_min = pTypes.SimpleParameter(**p) self.tile_size_min.itemClass = SliderWidgetParameterItem @updateGuard def updateTileSizeMax(): self.sigTileMaximum.emit(self.tile_size_max.value()) p.update( { "name": "tile_size_max", "value": model.quadtree.tile_size_max, "default": QuadtreeConfig.tile_size_max.default(), "tip": QuadtreeConfig.tile_size_max.help, } ) self.tile_size_max = pTypes.SimpleParameter(**p) self.tile_size_max.itemClass = SliderWidgetParameterItem self.tile_size_min.sigValueChanged.connect(updateTileSizeMin) self.tile_size_max.sigValueChanged.connect(updateTileSizeMax) # Component control @QtCore.pyqtSlot() def changeComponent(): self.plot.component = self.components.value() p = { "name": "display", "values": { "QuadNode.mean": "mean", "QuadNode.median": "median", "QuadNode.weight": "weight", }, "value": "mean", "tip": "Change displayed component", } self.components = pTypes.ListParameter(**p) self.components.sigValueChanged.connect(changeComponent) @QtCore.pyqtSlot() def changeCorrection(): model.quadtree.setCorrection(correction_method.value()) self.updateEpsilonLimits() p = { "name": "setCorrection", "values": { "Mean (Jonsson, 2002)": "mean", "Median (Jonsson, 2002)": "median", "Bilinear (Jonsson, 2002)": "bilinear", "SD (Jonsson, 2002)": "std", }, "value": model.quadtree.config.correction, "tip": QuadtreeConfig.correction.help, } correction_method = pTypes.ListParameter(**p) correction_method.sigValueChanged.connect(changeCorrection) self.sig_guard = False self.pushChild(correction_method) self.pushChild(self.tile_size_max) self.pushChild(self.tile_size_min) self.pushChild(self.nan_allowed) self.pushChild(self.epsilon) self.pushChild(self.components)