def parameter(self) -> Parameter:
if not self._param:
self._param = parameterTypes.GroupParameter(
name='Rectangular ROI',
children=[
parameterTypes.SimpleParameter(title='Width',
name='width',
value=self.width,
type='float',
units='px'),
parameterTypes.SimpleParameter(title='Height',
name='height',
value=self.height,
type='float',
units='px'),
parameterTypes.SimpleParameter(title='Horizontal Segments',
name='segments_h',
value=self.segments_h,
type='int'),
parameterTypes.SimpleParameter(title='Vertical Segments',
name='segments_v',
value=self.segments_v,
type='int')
])
self._param.sigTreeStateChanged.connect(self.valueChanged)
return self._param
def parameter(self):
if not self._param:
self._param = parameterTypes.GroupParameter(
name='Arc ROI',
children=[
parameterTypes.SimpleParameter(title='Q Minimum',
name='innerradius',
value=self.innerradius,
type='float',
units='Å⁻¹'),
parameterTypes.SimpleParameter(title='Q Maximum',
name='outerradius',
value=self.outerradius,
type='float',
units='Å⁻¹'),
parameterTypes.SimpleParameter(title='χ Width',
name='thetawidth',
value=self.thetawidth,
type='float',
units='°'),
parameterTypes.SimpleParameter(title='χ Center',
name='thetacenter',
value=self.thetacenter,
type='float',
siSuffix='°')
])
self._param.sigTreeStateChanged.connect(self.valueChanged)
return self._param
def parameter(self):
if not self._param:
self._param = parameterTypes.GroupParameter(
name="Arc ROI",
children=[
parameterTypes.SimpleParameter(
title=f"{self.radius_name} Minimum", name="innerradius", value=self.innerradius, type="float",
units=self.radius_units, min=0
# "Å⁻¹"
),
parameterTypes.SimpleParameter(
title=f"{self.radius_name} Maximum", name="outerradius", value=self.outerradius, type="float",
units=self.radius_units, min=0
),
parameterTypes.SimpleParameter(
title="χ Width", name="thetawidth", value=self.thetawidth, type="float", units="°"
),
parameterTypes.SimpleParameter(
title="χ Center", name="thetacenter", value=self.thetacenter, type="float", siSuffix="°"
),
],
)
self._param.sigTreeStateChanged.connect(self.valueChanged)
return self._param
def parameter(self) -> Parameter:
if not self._param:
self._param = parameterTypes.GroupParameter(
name='Line ROI',
children=[
parameterTypes.SimpleParameter(title='Center X',
name='center_x',
value=self.center_x,
type='float',
units='px'),
parameterTypes.SimpleParameter(title='Center Y',
name='center_y',
value=self.center_y,
type='float',
units='px'),
parameterTypes.SimpleParameter(title='Rotation Angle',
name='rotation',
value=self.rotation,
type='float',
units='px'),
parameterTypes.SimpleParameter(title='Length',
name='length',
value=self.length,
type='float',
units='px'),
parameterTypes.SimpleParameter(title='Width',
name='width',
value=self.width,
type='float',
units='px'),
])
self._param.sigTreeStateChanged.connect(self.valueChanged)
return self._param
def __init__(self, model, **kwargs):
scene = model.getScene()
kwargs["type"] = "group"
kwargs["name"] = "Scene.detrend"
KiteParameterGroup.__init__(self, model=model, model_attr="scene", **kwargs)
p = {
"name": "demean",
"type": "bool",
"value": scene.deramp.config.demean,
"tip": "substract mean of displacement",
}
self.demean = pTypes.SimpleParameter(**p)
def toggle_demean(param, checked):
self.model.getScene().deramp.set_demean(checked)
self.demean.sigValueChanged.connect(toggle_demean)
p = {
"name": "applied",
"type": "bool",
"value": scene.deramp.config.applied,
"tip": "detrend the scene",
}
self.applied = pTypes.SimpleParameter(**p)
def toggle_applied(param, checked):
self.model.getScene().deramp.set_enabled(checked)
self.applied.sigValueChanged.connect(toggle_applied)
self.pushChild(self.applied)
self.pushChild(self.demean)
def parameter(self) -> Parameter:
if not self._param:
self._param = parameterTypes.GroupParameter(
name="Rectangular ROI",
children=[
parameterTypes.SimpleParameter(title="Width",
name="width",
value=self.width,
type="float",
units="px"),
parameterTypes.SimpleParameter(title="Height",
name="height",
value=self.height,
type="float",
units="px"),
parameterTypes.SimpleParameter(title="Horizontal Segments",
name="segments_h",
value=self.segments_h,
type="int"),
parameterTypes.SimpleParameter(title="Vertical Segments",
name="segments_v",
value=self.segments_v,
type="int"),
],
)
self._param.sigTreeStateChanged.connect(self.valueChanged)
return self._param
def __init__(self, source_node, **kwargs):
kwargs["title"] = "Input file"
super().__init__(source_node, **kwargs)
try:
file_path = source_node.file_path
except Exception:
file_path = ""
# Add LineEdit for choosing file
file_path_str = parameterTypes.SimpleParameter(
type="str", name=self.FILE_PATH_STR_NAME, value=file_path)
file_path_str.setValue(file_path)
file_path_str.sigValueChanged.connect(self._on_file_path_changed)
self.file_path_str = self.addChild(file_path_str)
# Add PushButton for choosing file
file_path_button = parameterTypes.ActionParameter(
type="action", name="Select data...")
file_path_button.sigActivated.connect(self._choose_file)
self.file_path_button = self.addChild(file_path_button)
def __init__(self, pipeline, **kwargs):
kwargs['title'] = 'Input file'
super().__init__(pipeline, **kwargs)
try:
file_path = pipeline.source.file_path
except Exception:
file_path = ''
# Add LineEdit for choosing file
file_path_str = parameterTypes.SimpleParameter(
type='str', name=self.FILE_PATH_STR_NAME, value=file_path)
file_path_str.sigValueChanged.connect(self._on_file_path_changed)
self.file_path_str = self.addChild(file_path_str)
# Add PushButton for choosing file
file_path_button = parameterTypes.ActionParameter(
type='action', name="Select data...")
file_path_button.sigActivated.connect(self._choose_file)
self.file_path_button = self.addChild(file_path_button)
def _create_parameters(self):
stream_name = self._output_node.stream_name
stream_name_str = parameterTypes.SimpleParameter(
type='str',
name=self.STREAM_NAME_STR_NAME,
value=stream_name,
editable=False)
stream_name_str.sigValueChanged.connect(self._on_stream_name_changed)
self.stream_name_str = self.addChild(stream_name_str)
def _create_parameters(self):
n_lines = parameterTypes.SimpleParameter(
type="int",
name="Number of connections",
value=self._output_node.n_lines,
readonly=False,
)
self.n_lines = self.addChild(n_lines)
self.n_lines.sigValueChanged.connect(self._on_n_lines_changed)
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 _add_disable_parameter(self):
disabled_value = False # TODO: change once disabling is implemented
disabled = parameterTypes.SimpleParameter(
type="bool",
name=self.DISABLED_NAME,
value=disabled_value,
readonly=False,
)
disabled.sigValueChanged.connect(self._on_disabled_changed)
self.disabled = self.addChild(disabled)
self._source_node._signal_sender.disabled_changed.connect(
self.disabled.setValue)
def __init__(self, name):
super(spacegroup, self).__init__(name=name)
self.alpha = pTypes.SimpleParameter(type='float',
name=u'α',
value=90,
step=.01)
self.beta = pTypes.SimpleParameter(type='float',
name=u'β',
value=90,
step=.01)
self.gamma = pTypes.SimpleParameter(type='float',
name=u'γ',
value=90,
step=.01)
self.a = pTypes.SimpleParameter(type='float',
name='a',
value=10.e-9,
step=1.e-9,
suffix='m',
siPrefix=True)
self.b = pTypes.SimpleParameter(type='float',
name='b',
value=10.e-9,
step=1.e-9,
suffix='m',
siPrefix=True)
self.c = pTypes.SimpleParameter(type='float',
name='c',
value=10.e-9,
step=1.e-9,
suffix='m',
siPrefix=True)
self.addChildren(
[self.alpha, self.beta, self.gamma, self.a, self.b, self.c])
def __init__(self, pipeline, **kwargs):
kwargs['title'] = 'Brainvision file'
super().__init__(pipeline, **kwargs)
try:
file_path = pipeline.source.file_path
except:
file_path = ''
file_path_str = parameterTypes.SimpleParameter(
type='str', name=self.FILE_PATH_STR_NAME, value=file_path)
file_path_str.sigValueChanged.connect(self._on_file_path_changed)
self.file_path_str = self.addChild(file_path_str)
def parameter(self) -> Parameter:
if not self._param:
self._param = parameterTypes.GroupParameter(
name="Line ROI",
children=[
parameterTypes.SimpleParameter(
title="Center X", name="center_x", value=self.center_x, type="float", units="px"
),
parameterTypes.SimpleParameter(
title="Center Y", name="center_y", value=self.center_y, type="float", units="px"
),
parameterTypes.SimpleParameter(
title="Rotation Angle", name="rotation", value=self.rotation, type="float", units="px"
),
parameterTypes.SimpleParameter(
title="Length", name="length", value=self.length, type="float", units="px"
),
parameterTypes.SimpleParameter(title="Width", name="width", value=self.width, type="float", units="px"),
],
)
self._param.sigTreeStateChanged.connect(self.valueChanged)
return self._param
def __init__(self, model, **kwargs):
scene = model.getScene()
kwargs['type'] = 'group'
kwargs['name'] = 'Scene.detrend'
KiteParameterGroup.__init__(
self, model=model, model_attr='scene', **kwargs)
p = {
'name': 'demean',
'type': 'bool',
'value': scene.deramp.config.demean,
'tip': 'substract mean of displacement'
}
self.demean = pTypes.SimpleParameter(**p)
def toggle_demean(param, checked):
self.model.getScene().deramp.set_demean(checked)
self.demean.sigValueChanged.connect(toggle_demean)
p = {
'name': 'applied',
'type': 'bool',
'value': scene.deramp.config.applied,
'tip': 'detrend the scene'
}
self.applied = pTypes.SimpleParameter(**p)
def toggle_applied(param, checked):
self.model.getScene().deramp.set_enabled(checked)
self.applied.sigValueChanged.connect(toggle_applied)
self.pushChild(self.applied)
self.pushChild(self.demean)
def _create_parameters(self):
file_path = self._output_node.output_path
file_path_str = parameterTypes.SimpleParameter(
type="str", name=self.FILE_PATH_STR_NAME, value=file_path)
file_path_str.sigValueChanged.connect(self._on_file_path_changed)
self.file_path_str = self.addChild(file_path_str)
# Add PushButton for choosing file
file_path_button = parameterTypes.ActionParameter(
type="action", name="Change output file")
file_path_button.sigActivated.connect(self._choose_file)
self.file_path_button = self.addChild(file_path_button)
start_stop_button = parameterTypes.ActionParameter(type="action",
name="Start")
start_stop_button.sigActivated.connect(self._on_start_stop_toggled)
self.start_stop_button = self.addChild(start_stop_button)
def __init__(self, model, **kwargs):
scene = model.getScene()
kwargs["type"] = "group"
kwargs["name"] = "Scene.APS (empirical)"
KiteParameterGroup.__init__(self,
model=model,
model_attr="scene",
**kwargs)
p = {
"name": "applied",
"type": "bool",
"value": scene.aps.config.applied,
"tip": "detrend the scene",
}
self.applied = pTypes.SimpleParameter(**p)
def toggle_applied(param, checked):
self.model.getScene().aps.set_enabled(checked)
self.applied.sigValueChanged.connect(toggle_applied)
self.pushChild(self.applied)
def __init__(self, model, **kwargs):
scene = model.getScene()
kwargs['type'] = 'group'
kwargs['name'] = 'Scene.APS (empirical)'
KiteParameterGroup.__init__(self,
model=model,
model_attr='scene',
**kwargs)
p = {
'name': 'applied',
'type': 'bool',
'value': scene.aps.config.applied,
'tip': 'detrend the scene'
}
self.applied = pTypes.SimpleParameter(**p)
def toggle_applied(param, checked):
self.model.getScene().aps.set_enabled(checked)
self.applied.sigValueChanged.connect(toggle_applied)
self.pushChild(self.applied)
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):
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 __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)
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):
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 __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 _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, 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)
