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 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 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