def setData(self, data):
data = self.normalizeData(data)
nxd = NXdata(data)
signal_name = get_attr_as_string(data, "signal")
# signal_errors = nx.errors # not supported
group_name = data.name
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().setCurveData(y_axis,
x_axis,
values=nxd.signal,
yerror=y_errors,
xerror=x_errors,
ylabel=signal_name,
xlabel=x_label,
title="NXdata group " + group_name)
def setData(self, data):
data = self.normalizeData(data)
nxd = NXdata(data)
signal_name = get_attr_as_string(data, "signal")
group_name = data.name
y_axis, x_axis = nxd.axes[-2:]
y_label, x_label = nxd.axes_names[-2:]
self.getWidget().setImageData(nxd.signal,
x_axis=x_axis,
y_axis=y_axis,
signal_name=signal_name,
xlabel=x_label,
ylabel=y_label,
title="NXdata group %s: %s" %
(group_name, signal_name))
def setData(self, data):
data = self.normalizeData(data)
nxd = NXdata(data)
signal_name = get_attr_as_string(data, "signal")
group_name = data.name
if nxd.axes_dataset_names[-1] is not None:
x_errors = nxd.get_axis_errors(nxd.axes_dataset_names[-1])
else:
x_errors = None
self.getWidget().setCurveData(nxd.signal,
nxd.axes[-1],
yerror=nxd.errors,
xerror=x_errors,
ylabel=signal_name,
xlabel=nxd.axes_names[-1],
title="NXdata group " + group_name)
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.isNXdata = False
self.shape = tuple()
self.dim = 0
self.size = 0
if data is None:
return
if silx.io.is_group(data) and nxdata.is_valid_nxdata(data):
self.isNXdata = True
nxd = nxdata.NXdata(data)
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.isNXdata:
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.complex)
self.isBoolean = numpy.issubdtype(data.dtype, numpy.bool_)
elif self.isNXdata:
self.isNumeric = numpy.issubdtype(nxd.signal.dtype, numpy.number)
self.isComplex = numpy.issubdtype(nxd.signal.dtype, numpy.complex)
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.isNXdata:
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 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
