def getDataPriority(self, data, info):
data = self.normalizeData(data)
if info.hasNXdata:
if nxdata.get_default(data).is_x_y_value_scatter:
return 100
return DataView.UNSUPPORTED
def setData(self, data):
data = self.normalizeData(data)
# data could be a NXdata or an NXentry
nxd = nxdata.get_default(data)
signal = nxd.signal
self.getWidget().setArrayData(signal,
labels=True)
def setData(self, data):
data = self.normalizeData(data)
nxd = nxdata.get_default(data, validate=False)
x_axis, y_axis = nxd.axes[-2:]
x_label, y_label = nxd.axes_names[-2:]
if x_label is not None:
x_errors = nxd.get_axis_errors(x_label)
else:
x_errors = None
if y_label is not None:
y_errors = nxd.get_axis_errors(y_label)
else:
y_errors = None
self.getWidget().setScattersData(
y_axis,
x_axis,
values=[nxd.signal] + nxd.auxiliary_signals,
yerror=y_errors,
xerror=x_errors,
ylabel=y_label,
xlabel=x_label,
title=nxd.title,
scatter_titles=[nxd.signal_name] + nxd.auxiliary_signals_names)
def setData(self, data):
data = self.normalizeData(data)
nxd = nxdata.get_default(data, validate=False)
signals_names = [nxd.signal_name] + nxd.auxiliary_signals_names
if nxd.axes_dataset_names[-1] is not None:
x_errors = nxd.get_axis_errors(nxd.axes_dataset_names[-1])
else:
x_errors = None
# this fix is necessary until the next release of PyMca (5.2.3 or 5.3.0)
# see https://github.com/vasole/pymca/issues/144 and https://github.com/vasole/pymca/pull/145
if not hasattr(self.getWidget(), "setCurvesData") and \
hasattr(self.getWidget(), "setCurveData"):
_logger.warning("Using deprecated ArrayCurvePlot API, "
"without support of auxiliary signals")
self.getWidget().setCurveData(nxd.signal, nxd.axes[-1],
yerror=nxd.errors, xerror=x_errors,
ylabel=nxd.signal_name, xlabel=nxd.axes_names[-1],
title=nxd.title or nxd.signal_name)
return
self.getWidget().setCurvesData([nxd.signal] + nxd.auxiliary_signals, nxd.axes[-1],
yerror=nxd.errors, xerror=x_errors,
ylabels=signals_names, xlabel=nxd.axes_names[-1],
title=nxd.title or signals_names[0])
def setData(self, data):
data = self.normalizeData(data)
nxd = nxdata.get_default(data, validate=False)
signals_names = [nxd.signal_name] + nxd.auxiliary_signals_names
if nxd.axes_dataset_names[-1] is not None:
x_errors = nxd.get_axis_errors(nxd.axes_dataset_names[-1])
else:
x_errors = None
# this fix is necessary until the next release of PyMca (5.2.3 or 5.3.0)
# see https://github.com/vasole/pymca/issues/144 and https://github.com/vasole/pymca/pull/145
if not hasattr(self.getWidget(), "setCurvesData") and \
hasattr(self.getWidget(), "setCurveData"):
_logger.warning("Using deprecated ArrayCurvePlot API, "
"without support of auxiliary signals")
self.getWidget().setCurveData(nxd.signal,
nxd.axes[-1],
yerror=nxd.errors,
xerror=x_errors,
ylabel=nxd.signal_name,
xlabel=nxd.axes_names[-1],
title=nxd.title or nxd.signal_name)
return
self.getWidget().setCurvesData([nxd.signal] + nxd.auxiliary_signals,
nxd.axes[-1],
yerror=nxd.errors,
xerror=x_errors,
ylabels=signals_names,
xlabel=nxd.axes_names[-1],
title=nxd.title or signals_names[0])
def getDataPriority(self, data, info):
data = self.normalizeData(data)
if info.hasNXdata and not info.isInvalidNXdata:
if nxdata.get_default(data, validate=False).is_stack:
return 100
return DataView.UNSUPPORTED
def getDataPriority(self, data, info):
data = self.normalizeData(data)
if info.hasNXdata and not info.isInvalidNXdata:
if nxdata.get_default(data, validate=False).is_stack:
return 100
return DataView.UNSUPPORTED
def setData(self, data):
data = self.normalizeData(data)
nxd = nxdata.get_default(data, validate=False)
x_axis, y_axis = nxd.axes[-2:]
if x_axis is None:
x_axis = numpy.arange(nxd.signal.size)
if y_axis is None:
y_axis = numpy.arange(nxd.signal.size)
x_label, y_label = nxd.axes_names[-2:]
if x_label is not None:
x_errors = nxd.get_axis_errors(x_label)
else:
x_errors = None
if y_label is not None:
y_errors = nxd.get_axis_errors(y_label)
else:
y_errors = None
self.getWidget().setScattersData(y_axis, x_axis, values=[nxd.signal] + nxd.auxiliary_signals,
yerror=y_errors, xerror=x_errors,
ylabel=y_label, xlabel=x_label,
title=nxd.title,
scatter_titles=[nxd.signal_name] + nxd.auxiliary_signals_names)
def setData(self, data):
data = self.normalizeData(data)
# data could be a NXdata or an NXentry
nxd = nxdata.get_default(data, validate=False)
signal = nxd.signal
self.getWidget().setArrayData(signal,
labels=True)
def getDataPriority(self, data, info):
data = self.normalizeData(data)
if info.hasNXdata and not info.isInvalidNXdata:
nxd = nxdata.get_default(data, validate=False)
if nxd.signal_is_0d or nxd.interpretation in ["scalar", "scaler"]:
return 100
return DataView.UNSUPPORTED
def getDataPriority(self, data, info):
data = self.normalizeData(data)
if info.hasNXdata and not info.isInvalidNXdata:
nxd = nxdata.get_default(data, validate=False)
if nxd.signal_is_0d or nxd.interpretation in ["scalar", "scaler"]:
return 100
return DataView.UNSUPPORTED
def setData(self, data):
data = self.normalizeData(data)
nxd = nxdata.get_default(data, validate=False)
signal_name = nxd.signal_name
z_axis, y_axis, x_axis = nxd.axes[-3:]
z_label, y_label, x_label = nxd.axes_names[-3:]
title = nxd.title or signal_name
widget = self.getWidget()
widget.setStackData(
nxd.signal, x_axis=x_axis, y_axis=y_axis, z_axis=z_axis,
signal_name=signal_name,
xlabel=x_label, ylabel=y_label, zlabel=z_label,
title=title)
# Override the colormap, while setStack overwrite it
widget.getStackView().setColormap(self.defaultColormap())
def setData(self, data):
data = self.normalizeData(data)
nxd = nxdata.get_default(data, validate=False)
isRgba = nxd.interpretation == "rgba-image"
# last two axes are Y & X
img_slicing = slice(-2, None) if not isRgba else slice(-3, -1)
y_axis, x_axis = nxd.axes[img_slicing]
y_label, x_label = nxd.axes_names[img_slicing]
self.getWidget().setImageData(
[nxd.signal] + nxd.auxiliary_signals,
x_axis=x_axis, y_axis=y_axis,
signals_names=[nxd.signal_name] + nxd.auxiliary_signals_names,
xlabel=x_label, ylabel=y_label,
title=nxd.title, isRgba=isRgba)
def setData(self, data):
data = self.normalizeData(data)
nxd = nxdata.get_default(data)
signal_name = nxd.signal_name
z_axis, y_axis, x_axis = nxd.axes[-3:]
z_label, y_label, x_label = nxd.axes_names[-3:]
title = nxd.title or signal_name
widget = self.getWidget()
widget.setStackData(
nxd.signal, x_axis=x_axis, y_axis=y_axis, z_axis=z_axis,
signal_name=signal_name,
xlabel=x_label, ylabel=y_label, zlabel=z_label,
title=title)
# Override the colormap, while setStack overwrite it
widget.getStackView().setColormap(self.defaultColormap())
def setData(self, data):
data = self.normalizeData(data)
nxd = nxdata.get_default(data)
isRgba = nxd.interpretation == "rgba-image"
# last two axes are Y & X
img_slicing = slice(-2, None) if not isRgba else slice(-3, -1)
y_axis, x_axis = nxd.axes[img_slicing]
y_label, x_label = nxd.axes_names[img_slicing]
self.getWidget().setImageData(
[nxd.signal] + nxd.auxiliary_signals,
x_axis=x_axis, y_axis=y_axis,
signals_names=[nxd.signal_name] + nxd.auxiliary_signals_names,
xlabel=x_label, ylabel=y_label,
title=nxd.title, isRgba=isRgba)
def getDataPriority(self, data, info):
data = self.normalizeData(data)
if silx.io.is_group(data):
nxd = nxdata.get_default(data)
nx_class = get_attr_as_string(data, "NX_class")
if nxd is None:
if nx_class == "NXdata":
# invalid: could not even be parsed by NXdata
self._msg = "Group has @NX_class = NXdata, but could not be interpreted"
self._msg += " as valid NXdata."
return 100
elif nx_class == "NXentry":
if "default" not in data.attrs:
# no link to NXdata, no problem
return DataView.UNSUPPORTED
self._msg = "NXentry group provides a @default attribute,"
default_nxdata_name = data.attrs["default"]
if default_nxdata_name not in data:
self._msg += " but no corresponding NXdata group exists."
elif get_attr_as_string(data[default_nxdata_name], "NX_class") != "NXdata":
self._msg += " but the corresponding item is not a "
self._msg += "NXdata group."
else:
self._msg += " but the corresponding NXdata seems to be"
self._msg += " malformed."
return 100
elif nx_class == "NXroot" or silx.io.is_file(data):
if "default" not in data.attrs:
# no link to NXentry, no problem
return DataView.UNSUPPORTED
default_entry_name = data.attrs["default"]
if default_entry_name not in data:
# this is a problem, but not NXdata related
return DataView.UNSUPPORTED
default_entry = data[default_entry_name]
if "default" not in default_entry.attrs:
# no NXdata specified, no problemo
return DataView.UNSUPPORTED
default_nxdata_name = default_entry.attrs["default"]
self._msg = "NXroot group provides a @default attribute "
self._msg += "pointing to a NXentry which defines its own "
self._msg += "@default attribute, "
if default_nxdata_name not in default_entry:
self._msg += " but no corresponding NXdata group exists."
elif get_attr_as_string(default_entry[default_nxdata_name],
"NX_class") != "NXdata":
self._msg += " but the corresponding item is not a "
self._msg += "NXdata group."
else:
self._msg += " but the corresponding NXdata seems to be"
self._msg += " malformed."
return 100
else:
# Not pretending to be NXdata, no problem
return DataView.UNSUPPORTED
is_scalar = nxd.signal_is_0d or nxd.interpretation in ["scalar", "scaler"]
if not (is_scalar or nxd.is_curve or nxd.is_x_y_value_scatter or
nxd.is_image or nxd.is_stack):
# invalid: cannot be plotted by any widget (I cannot imagine a case)
self._msg = "NXdata seems valid, but cannot be displayed "
self._msg += "by any existing plot widget."
return 100
return DataView.UNSUPPORTED
def __init__(self, data):
data = self.normalizeData(data)
self.isArray = False
self.interpretation = None
self.isNumeric = False
self.isVoid = False
self.isComplex = False
self.isBoolean = False
self.isRecord = False
self.hasNXdata = False
self.isInvalidNXdata = False
self.shape = tuple()
self.dim = 0
self.size = 0
if data is None:
return
if silx.io.is_group(data):
nxd = nxdata.get_default(data)
nx_class = get_attr_as_unicode(data, "NX_class")
if nxd is not None:
self.hasNXdata = True
# can we plot it?
is_scalar = nxd.signal_is_0d or nxd.interpretation in ["scalar", "scaler"]
if not (is_scalar or nxd.is_curve or nxd.is_x_y_value_scatter or
nxd.is_image or nxd.is_stack):
# invalid: cannot be plotted by any widget
self.isInvalidNXdata = True
elif nx_class == "NXdata":
# group claiming to be NXdata could not be parsed
self.isInvalidNXdata = True
elif nx_class == "NXroot" or silx.io.is_file(data):
# root claiming to have a default entry
if "default" in data.attrs:
def_entry = data.attrs["default"]
if def_entry in data and "default" in data[def_entry].attrs:
# and entry claims to have default NXdata
self.isInvalidNXdata = True
elif "default" in data.attrs:
# group claiming to have a default NXdata could not be parsed
self.isInvalidNXdata = True
if isinstance(data, numpy.ndarray):
self.isArray = True
elif silx.io.is_dataset(data) and data.shape != tuple():
self.isArray = True
else:
self.isArray = False
if silx.io.is_dataset(data):
if "interpretation" in data.attrs:
self.interpretation = get_attr_as_unicode(data, "interpretation")
else:
self.interpretation = None
elif self.hasNXdata:
self.interpretation = nxd.interpretation
else:
self.interpretation = None
if hasattr(data, "dtype"):
if numpy.issubdtype(data.dtype, numpy.void):
# That's a real opaque type, else it is a structured type
self.isVoid = data.dtype.fields is None
self.isNumeric = numpy.issubdtype(data.dtype, numpy.number)
self.isRecord = data.dtype.fields is not None
self.isComplex = numpy.issubdtype(data.dtype, numpy.complexfloating)
self.isBoolean = numpy.issubdtype(data.dtype, numpy.bool_)
elif self.hasNXdata:
self.isNumeric = numpy.issubdtype(nxd.signal.dtype,
numpy.number)
self.isComplex = numpy.issubdtype(nxd.signal.dtype, numpy.complexfloating)
self.isBoolean = numpy.issubdtype(nxd.signal.dtype, numpy.bool_)
else:
self.isNumeric = isinstance(data, numbers.Number)
self.isComplex = isinstance(data, numbers.Complex)
self.isBoolean = isinstance(data, bool)
self.isRecord = False
if hasattr(data, "shape"):
self.shape = data.shape
elif self.hasNXdata:
self.shape = nxd.signal.shape
else:
self.shape = tuple()
if self.shape is not None:
self.dim = len(self.shape)
if hasattr(data, "shape") and data.shape is None:
# This test is expected to avoid to fall done on the h5py issue
# https://github.com/h5py/h5py/issues/1044
self.size = 0
elif hasattr(data, "size"):
self.size = int(data.size)
else:
self.size = 1
def __init__(self, data):
data = self.normalizeData(data)
self.isArray = False
self.interpretation = None
self.isNumeric = False
self.isVoid = False
self.isComplex = False
self.isBoolean = False
self.isRecord = False
self.hasNXdata = False
self.isInvalidNXdata = False
self.shape = tuple()
self.dim = 0
self.size = 0
if data is None:
return
if silx.io.is_group(data):
nxd = nxdata.get_default(data)
nx_class = get_attr_as_unicode(data, "NX_class")
if nxd is not None:
self.hasNXdata = True
# can we plot it?
is_scalar = nxd.signal_is_0d or nxd.interpretation in [
"scalar", "scaler"
]
if not (is_scalar or nxd.is_curve or nxd.is_x_y_value_scatter
or nxd.is_image or nxd.is_stack):
# invalid: cannot be plotted by any widget
self.isInvalidNXdata = True
elif nx_class == "NXdata":
# group claiming to be NXdata could not be parsed
self.isInvalidNXdata = True
elif nx_class == "NXentry" and "default" in data.attrs:
# entry claiming to have a default NXdata could not be parsed
self.isInvalidNXdata = True
elif nx_class == "NXroot" or silx.io.is_file(data):
# root claiming to have a default entry
if "default" in data.attrs:
def_entry = data.attrs["default"]
if def_entry in data and "default" in data[def_entry].attrs:
# and entry claims to have default NXdata
self.isInvalidNXdata = True
if isinstance(data, numpy.ndarray):
self.isArray = True
elif silx.io.is_dataset(data) and data.shape != tuple():
self.isArray = True
else:
self.isArray = False
if silx.io.is_dataset(data):
if "interpretation" in data.attrs:
self.interpretation = get_attr_as_unicode(
data, "interpretation")
else:
self.interpretation = None
elif self.hasNXdata:
self.interpretation = nxd.interpretation
else:
self.interpretation = None
if hasattr(data, "dtype"):
if numpy.issubdtype(data.dtype, numpy.void):
# That's a real opaque type, else it is a structured type
self.isVoid = data.dtype.fields is None
self.isNumeric = numpy.issubdtype(data.dtype, numpy.number)
self.isRecord = data.dtype.fields is not None
self.isComplex = numpy.issubdtype(data.dtype,
numpy.complexfloating)
self.isBoolean = numpy.issubdtype(data.dtype, numpy.bool_)
elif self.hasNXdata:
self.isNumeric = numpy.issubdtype(nxd.signal.dtype, numpy.number)
self.isComplex = numpy.issubdtype(nxd.signal.dtype,
numpy.complexfloating)
self.isBoolean = numpy.issubdtype(nxd.signal.dtype, numpy.bool_)
else:
self.isNumeric = isinstance(data, numbers.Number)
self.isComplex = isinstance(data, numbers.Complex)
self.isBoolean = isinstance(data, bool)
self.isRecord = False
if hasattr(data, "shape"):
self.shape = data.shape
elif self.hasNXdata:
self.shape = nxd.signal.shape
else:
self.shape = tuple()
if self.shape is not None:
self.dim = len(self.shape)
if hasattr(data, "size"):
self.size = int(data.size)
else:
self.size = 1
def __init__(self, data):
data = self.normalizeData(data)
self.isArray = False
self.interpretation = None
self.isNumeric = False
self.isVoid = False
self.isComplex = False
self.isBoolean = False
self.isRecord = False
self.hasNXdata = False
self.shape = tuple()
self.dim = 0
self.size = 0
if data is None:
return
if silx.io.is_group(data):
nxd = nxdata.get_default(data)
if nxd is not None:
self.hasNXdata = True
if isinstance(data, numpy.ndarray):
self.isArray = True
elif silx.io.is_dataset(data) and data.shape != tuple():
self.isArray = True
else:
self.isArray = False
if silx.io.is_dataset(data):
if "interpretation" in data.attrs:
self.interpretation = get_attr_as_string(data, "interpretation")
else:
self.interpretation = None
elif self.hasNXdata:
self.interpretation = nxd.interpretation
else:
self.interpretation = None
if hasattr(data, "dtype"):
if numpy.issubdtype(data.dtype, numpy.void):
# That's a real opaque type, else it is a structured type
self.isVoid = data.dtype.fields is None
self.isNumeric = numpy.issubdtype(data.dtype, numpy.number)
self.isRecord = data.dtype.fields is not None
self.isComplex = numpy.issubdtype(data.dtype, numpy.complexfloating)
self.isBoolean = numpy.issubdtype(data.dtype, numpy.bool_)
elif self.hasNXdata:
self.isNumeric = numpy.issubdtype(nxd.signal.dtype,
numpy.number)
self.isComplex = numpy.issubdtype(nxd.signal.dtype, numpy.complexfloating)
self.isBoolean = numpy.issubdtype(nxd.signal.dtype, numpy.bool_)
else:
self.isNumeric = isinstance(data, numbers.Number)
self.isComplex = isinstance(data, numbers.Complex)
self.isBoolean = isinstance(data, bool)
self.isRecord = False
if hasattr(data, "shape"):
self.shape = data.shape
elif self.hasNXdata:
self.shape = nxd.signal.shape
else:
self.shape = tuple()
if self.shape is not None:
self.dim = len(self.shape)
if hasattr(data, "size"):
self.size = int(data.size)
else:
self.size = 1
