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)
