hyperspy._signals.lazy module
- class hyperspy._signals.lazy.LazySignal(*args, **kwargs)
Bases:
BaseSignal
A Lazy Signal instance that delays computation until explicitly saved (assuming storing the full result of computation in memory is not feasible)
Create a Signal from a numpy array.
- Parameters:
data (
numpy.ndarray
) – The signal data. It can be an array of any dimensions.axes ([dict/axes], optional) – List of either dictionaries or axes objects to define the axes (see the documentation of the
AxesManager
class for more details).attributes (dict, optional) – A dictionary whose items are stored as attributes.
metadata (dict, optional) – A dictionary containing a set of parameters that will to stores in the
metadata
attribute. Some parameters might be mandatory in some cases.original_metadata (dict, optional) – A dictionary containing a set of parameters that will to stores in the
original_metadata
attribute. It typically contains all the parameters that has been imported from the original data file.ragged (bool or None, optional) – Define whether the signal is ragged or not. Overwrite the
ragged
value in theattributes
dictionary. If None, it does nothing. Default is None.
- _block_iterator(flat_signal=True, get=<function get>, navigation_mask=None, signal_mask=None)
A function that allows iterating lazy signal data by blocks, defining the dask.Array.
- Parameters:
flat_signal (bool) – returns each block flattened, such that the shape (for the particular block) is (navigation_size, signal_size), with optionally masked elements missing. If false, returns the equivalent of s.inav[{blocks}].data, where masked elements are set to np.nan or 0.
get (dask scheduler) – the dask scheduler to use for computations; default dask.threaded.get
navigation_mask ({BaseSignal, numpy array, dask array}) – The navigation locations marked as True are not returned (flat) or set to NaN or 0.
signal_mask ({BaseSignal, numpy array, dask array}) – The signal locations marked as True are not returned (flat) or set to NaN or 0.
- _get_cache_dask_chunk(indices)
Method for handling caching of dask chunks, when using __call__.
When accessing data in a chunked HDF5 file, the whole chunks needs to be loaded into memory. So even if you only want to access a single index in the navigation dimension, the whole chunk in the navigation dimension needs to be loaded into memory. This method keeps (caches) this chunk in memory after loading it, so moving to a different position with the same chunk will be much faster, reducing amount of data which needs be read from the disk.
If a navigation index (via the indices parameter) in a different chunk is asked for, the currently cached chunk is discarded, and the new chunk is loaded into memory.
This only works for functions using self.__call__, for example plot and fitting functions. This will not work with the region of interest functionality.
The cached chunk is stored in the attribute s._cache_dask_chunk, and the slice needed to extract this chunk is in s._cache_dask_chunk_slice. To these, use s._clear_cache_dask_data()
- Parameters:
indices (tuple) – Must be the same length as navigation dimensions in self.
- Returns:
value – Same shape as the signal shape of self.
- Return type:
NumPy array
Examples
>>> import dask.array as da >>> s = hs.signals.Signal2D(da.ones((5, 10, 20, 30, 40))).as_lazy() >>> value = s._get_cache_dask_chunk((3, 6, 2)) >>> cached_chunk = s._cache_dask_chunk # Cached array >>> cached_chunk_slice = s._cache_dask_chunk_slice # Slice of chunk >>> s._clear_cache_dask_data() # Clearing both of these
- _get_dask_chunks(axis=None, dtype=None)
Returns dask chunks.
- Aims:
Have at least one signal (or specified axis) in a single chunk, or as many as fit in memory
- Parameters:
axis ({int, string, None, axis, tuple}) – If axis is None (default), returns chunks for current data shape so that at least one signal is in the chunk. If an axis is specified, only that particular axis is guaranteed to be “not sliced”.
dtype ({string, np.dtype}) – The dtype of target chunks.
- Return type:
Tuple of tuples, dask chunks
- _get_file_handle(warn=True)
Return file handle when possible; currently only hdf5 file are supported.
- _lazy_data(axis=None, rechunk=True, dtype=None)
Return the data as a dask array, rechunked if necessary.
- Parameters:
axis (None, DataAxis or tuple of data axes) – The data axis that must not be broken into chunks when rechunk is True. If None, it defaults to the current signal axes.
rechunk (bool, "dask_auto") – If True, it rechunks the data if necessary making sure that the axes in
axis
are not split into chunks. If False it does not rechunk at least the data is not a dask array, in which case it chunks as if rechunk was True. If “dask_auto”, rechunk if necessary using dask’s automatic chunk guessing.
- change_dtype(dtype, rechunk=True)
Change the data type of a Signal.
- Parameters:
dtype (str or
numpy.dtype
) – Typecode string or data-type to which the Signal’s data array is cast. In addition to all the standard numpy Data type objects (dtype), HyperSpy supports four extra dtypes for RGB images:'rgb8'
,'rgba8'
,'rgb16'
, and'rgba16'
. Changing from and to anyrgb(a)
dtype is more constrained than most other dtype conversions. To change to anrgb(a)
dtype, the signal_dimension must be 1, and its size should be 3 (forrgb
) or 4 (forrgba
) dtypes. The original dtype should beuint8
oruint16
if converting torgb(a)8
orrgb(a))16
, and the navigation_dimension should be at least 2. After conversion, the signal_dimension becomes 2. The dtype of images with original dtypergb(a)8
orrgb(a)16
can only be changed touint8
oruint16
, and the signal_dimension becomes 1.rechunk (bool) – Only has effect when operating on lazy signal. If
True
(default), the data may be automatically rechunked before performing this operation.
Examples
>>> s = hs.signals.Signal1D([1,2,3,4,5]) >>> s.data array([1, 2, 3, 4, 5]) >>> s.change_dtype('float') >>> s.data array([ 1., 2., 3., 4., 5.])
- close_file()
Closes the associated data file if any.
Currently it only supports closing the file associated with a dask array created from an h5py DataSet (default HyperSpy hdf5 reader).
- compute(close_file=False, show_progressbar=None, **kwargs)
Attempt to store the full signal in memory.
- Parameters:
close_file (bool, default False) – If True, attemp to close the file associated with the dask array data if any. Note that closing the file will make all other associated lazy signals inoperative.
show_progressbar (None or bool) – If
True
, display a progress bar. IfNone
, the default from the preferences settings is used.
- Return type:
None
Compute the navigator by taking the sum over a single chunk contained the specified coordinate. Taking the sum over a single chunk is a computationally efficient approach to compute the navigator. The data can be rechunk by specifying the
chunks_number
argument.- Parameters:
index ((int, float, None) or iterable, optional) – Specified where to take the sum, follows HyperSpy indexing syntax for integer and float. If None, the index is the centre of the signal_space
chunks_number ((int, None) or iterable, optional) – Define the number of chunks in the signal space used for rechunk the when calculating of the navigator. Useful to define the range over which the sum is calculated. If None, the existing chunking will be considered when picking the chunk used in the navigator calculation.
show_progressbar (None or bool) – If
True
, display a progress bar. IfNone
, the default from the preferences settings is used.
- Return type:
None.
Note
The number of chunks will affect where the sum is taken. If the sum needs to be taken in the centre of the signal space (for example, in the case of diffraction pattern), the number of chunk needs to be an odd number, so that the middle is centered.
- decomposition(normalize_poissonian_noise=False, algorithm='SVD', output_dimension=None, signal_mask=None, navigation_mask=None, get=<function get>, num_chunks=None, reproject=True, print_info=True, **kwargs)
Perform Incremental (Batch) decomposition on the data.
The results are stored in
self.learning_results
.Read more in the User Guide.
- Parameters:
normalize_poissonian_noise (bool, default False) – If True, scale the signal to normalize Poissonian noise using the approach described in [KeenanKotula2004].
algorithm ({'SVD', 'PCA', 'ORPCA', 'ORNMF'}, default 'SVD') – The decomposition algorithm to use.
output_dimension (int or None, default None) – Number of components to keep/calculate. If None, keep all (only valid for ‘SVD’ algorithm)
get (dask scheduler) – the dask scheduler to use for computations; default dask.threaded.get
num_chunks (int or None, default None) – the number of dask chunks to pass to the decomposition model. More chunks require more memory, but should run faster. Will be increased to contain at least
output_dimension
signals.navigation_mask ({BaseSignal, numpy array, dask array}) – The navigation locations marked as True are not used in the decomposition. Not implemented for the ‘SVD’ algorithm.
signal_mask ({BaseSignal, numpy array, dask array}) – The signal locations marked as True are not used in the decomposition. Not implemented for the ‘SVD’ algorithm.
reproject (bool, default True) – Reproject data on the learnt components (factors) after learning.
print_info (bool, default True) – If True, print information about the decomposition being performed. In the case of sklearn.decomposition objects, this includes the values of all arguments of the chosen sklearn algorithm.
**kwargs – passed to the partial_fit/fit functions.
References
[KeenanKotula2004]M. Keenan and P. Kotula, “Accounting for Poisson noise in the multivariate analysis of ToF-SIMS spectrum images”, Surf. Interface Anal 36(3) (2004): 203-212.
See also
decomposition()
for non-lazy signals
- diff(axis, order=1, out=None, rechunk=True)
Returns a signal with the n-th order discrete difference along given axis. i.e. it calculates the difference between consecutive values in the given axis: out[n] = a[n+1] - a[n]. See
numpy.diff()
for more details.- Parameters:
axis (
int
,str
, orDataAxis
) – The axis can be passed directly, or specified using the index of the axis in the Signal’s axes_manager or the axis name.order (int) – The order of the discrete difference.
out (
BaseSignal
(or subclasses) orNone
) – IfNone
, a new Signal is created with the result of the operation and returned (default). If a Signal is passed, it is used to receive the output of the operation, and nothing is returned.rechunk (bool) – Only has effect when operating on lazy signal. If
True
(default), the data may be automatically rechunked before performing this operation.
- Returns:
s – Note that the size of the data on the given
axis
decreases by the givenorder
. i.e. ifaxis
is"x"
andorder
is 2, the x dimension is N,der
’s x dimension is N - 2.- Return type:
BaseSignal
(or subclasses) or None
Note
If you intend to calculate the numerical derivative, please use the proper
derivative()
function instead. To avoid erroneous misuse of the diff function as derivative, it raises an error when when working with a non-uniform axis.See also
derivative
,integrate1D
,integrate_simpson
Examples
>>> import numpy as np >>> s = BaseSignal(np.random.random((64,64,1024))) >>> s.data.shape (64,64,1024) >>> s.diff(-1).data.shape (64,64,1023)
- get_chunk_size(axes=None)
Returns the chunk size as tuple for a set of given axes. The order of the returned tuple follows the order of the dask array.
- Parameters:
axes (:
int
,str
,DataAxis
, tuple (of DataAxis) orNone
) – Either one on its own, or many axes in a tuple can be passed. In both cases the axes can be passed directly, or specified using the index in axes_manager or the name of the axis. Any duplicates are removed. IfNone
, the operation is performed over all navigation axes (default).
Examples
>>> import dask.array as da >>> data = da.random.random((10, 200, 300)) >>> data.chunksize (10, 200, 300) >>> s = hs.signals.Signal1D(data).as_lazy() >>> s.get_chunk_size() # All navigation axes ((10,), (200,)) >>> s.get_chunk_size(0) # The first navigation axis ((200,),)
- get_histogram(bins='fd', out=None, rechunk=True, **kwargs)
Return a histogram of the signal data.
More sophisticated algorithms for determining the bins can be used by passing a string as the
bins
argument. Other than the'blocks'
and'knuth'
methods, the available algorithms are the same asnumpy.histogram()
.Note: The lazy version of the algorithm only supports
"scott"
and"fd"
as a string argument forbins
.- Parameters:
bins (int or sequence of scalars or str, default "fd") –
If bins is an int, it defines the number of equal-width bins in the given range. If bins is a sequence, it defines the bin edges, including the rightmost edge, allowing for non-uniform bin widths.
If bins is a string from the list below, will use the method chosen to calculate the optimal bin width and consequently the number of bins (see Notes for more detail on the estimators) from the data that falls within the requested range. While the bin width will be optimal for the actual data in the range, the number of bins will be computed to fill the entire range, including the empty portions. For visualisation, using the ‘auto’ option is suggested. Weighted data is not supported for automated bin size selection.
- ’auto’
Maximum of the ‘sturges’ and ‘fd’ estimators. Provides good all around performance.
- ’fd’ (Freedman Diaconis Estimator)
Robust (resilient to outliers) estimator that takes into account data variability and data size.
- ’doane’
An improved version of Sturges’ estimator that works better with non-normal datasets.
- ’scott’
Less robust estimator that that takes into account data variability and data size.
- ’stone’
Estimator based on leave-one-out cross-validation estimate of the integrated squared error. Can be regarded as a generalization of Scott’s rule.
- ’rice’
Estimator does not take variability into account, only data size. Commonly overestimates number of bins required.
- ’sturges’
R’s default method, only accounts for data size. Only optimal for gaussian data and underestimates number of bins for large non-gaussian datasets.
- ’sqrt’
Square root (of data size) estimator, used by Excel and other programs for its speed and simplicity.
- ’knuth’
Knuth’s rule is a fixed-width, Bayesian approach to determining the optimal bin width of a histogram.
- ’blocks’
Determination of optimal adaptive-width histogram bins using the Bayesian Blocks algorithm.
range_bins (tuple or None, optional) – the minimum and maximum range for the histogram. If range_bins is
None
, (x.min()
,x.max()
) will be used.max_num_bins (int, default 250) – When estimating the bins using one of the str methods, the number of bins is capped by this number to avoid a MemoryError being raised by
numpy.histogram()
.out (
BaseSignal
(or subclasses) orNone
) – IfNone
, a new Signal is created with the result of the operation and returned (default). If a Signal is passed, it is used to receive the output of the operation, and nothing is returned.rechunk (bool) – Only has effect when operating on lazy signal. If
True
(default), the data may be automatically rechunked before performing this operation.**kwargs – other keyword arguments (weight and density) are described in
numpy.histogram()
.
- Returns:
hist_spec – A 1D spectrum instance containing the histogram.
- Return type:
See also
print_summary_statistics
dask.histogram()
Examples
>>> s = hs.signals.Signal1D(np.random.normal(size=(10, 100))) >>> # Plot the data histogram >>> s.get_histogram().plot() >>> # Plot the histogram of the signal at the current coordinates >>> s.get_current_signal().get_histogram().plot()
- integrate_simpson(axis, out=None)
Calculate the integral of a Signal along an axis using Simpson’s rule.
- Parameters:
axis (
int
,str
, orDataAxis
) – The axis can be passed directly, or specified using the index of the axis in the Signal’s axes_manager or the axis name.out (
BaseSignal
(or subclasses) orNone
) – IfNone
, a new Signal is created with the result of the operation and returned (default). If a Signal is passed, it is used to receive the output of the operation, and nothing is returned.
- Returns:
s – A new Signal containing the integral of the provided Signal along the specified axis.
- Return type:
BaseSignal
(or subclasses)
See also
derivative
,integrate1D
Examples
>>> import numpy as np >>> s = BaseSignal(np.random.random((64,64,1024))) >>> s.data.shape (64,64,1024) >>> s.integrate_simpson(-1).data.shape (64,64)
- plot(navigator='auto', **kwargs)
Plot the signal at the current coordinates.
For multidimensional datasets an optional figure, the “navigator”, with a cursor to navigate that data is raised. In any case it is possible to navigate the data using the sliders. Currently only signals with signal_dimension equal to 0, 1 and 2 can be plotted.
- Parameters:
navigator (str, None, or
BaseSignal
(or subclass). Allowed string values are'auto'
,'slider'
, and'spectrum'
.) –If
'auto'
:If navigation_dimension > 0, a navigator is provided to explore the data.
If navigation_dimension is 1 and the signal is an image the navigator is a sum spectrum obtained by integrating over the signal axes (the image).
If navigation_dimension is 1 and the signal is a spectrum the navigator is an image obtained by stacking all the spectra in the dataset horizontally.
If navigation_dimension is > 1, the navigator is a sum image obtained by integrating the data over the signal axes.
Additionally, if navigation_dimension > 2, a window with one slider per axis is raised to navigate the data.
For example, if the dataset consists of 3 navigation axes X, Y, Z and one signal axis, E, the default navigator will be an image obtained by integrating the data over E at the current Z index and a window with sliders for the X, Y, and Z axes will be raised. Notice that changing the Z-axis index changes the navigator in this case.
For lazy signals, the navigator will be calculated using the
compute_navigator()
method.
If
'slider'
:If navigation dimension > 0 a window with one slider per axis is raised to navigate the data.
If
'spectrum'
:If navigation_dimension > 0 the navigator is always a spectrum obtained by integrating the data over all other axes.
Not supported for lazy signals, the
'auto'
option will be used instead.
If
None
, no navigator will be provided.Alternatively a
BaseSignal
(or subclass) instance can be provided. The navigation or signal shape must match the navigation shape of the signal to plot or the navigation_shape + signal_shape must be equal to the navigator_shape of the current object (for a dynamic navigator). If the signal dtype is RGB or RGBA this parameter has no effect and the value is always set to'slider'
.axes_manager (None or
AxesManager
) – If None, the signal’s axes_manager attribute is used.plot_markers (bool, default True) – Plot markers added using s.add_marker(marker, permanent=True). Note, a large number of markers might lead to very slow plotting.
navigator_kwds (dict) – Only for image navigator, additional keyword arguments for
matplotlib.pyplot.imshow()
.norm (str, optional) – The function used to normalize the data prior to plotting. Allowable strings are:
'auto'
,'linear'
,'log'
. (default value is'auto'
). If'auto'
, intensity is plotted on a linear scale except whenpower_spectrum=True
(only for complex signals).autoscale (str) – The string must contain any combination of the ‘x’ and ‘v’ characters. If ‘x’ or ‘v’ (for values) are in the string, the corresponding horizontal or vertical axis limits are set to their maxima and the axis limits will reset when the data or the navigation indices are changed. Default is ‘v’.
**kwargs (dict) – Only when plotting an image: additional (optional) keyword arguments for
matplotlib.pyplot.imshow()
.
- rebin(new_shape=None, scale=None, crop=False, dtype=None, out=None, rechunk=True)
Rebin the signal into a smaller or larger shape, based on linear interpolation. Specify either new_shape or scale. Scale of 1 means no binning and scale less than one results in up-sampling.
- Parameters:
new_shape (list (of floats or integer) or None) – For each dimension specify the new_shape. This will internally be converted into a
scale
parameter.scale (list (of floats or integer) or None) – For each dimension, specify the new:old pixel ratio, e.g. a ratio of 1 is no binning and a ratio of 2 means that each pixel in the new spectrum is twice the size of the pixels in the old spectrum. The length of the list should match the dimension of the Signal’s underlying data array. Note : Only one of `scale` or `new_shape` should be specified, otherwise the function will not run
crop (bool) – Whether or not to crop the resulting rebinned data (default is
True
). When binning by a non-integer number of pixels it is likely that the final row in each dimension will contain fewer than the full quota to fill one pixel. For example, a 5*5 array binned by 2.1 will produce two rows containing 2.1 pixels and one row containing only 0.8 pixels. Selection ofcrop=True
orcrop=False
determines whether or not this “black” line is cropped from the final binned array or not. Please note that if ``crop=False`` is used, the final row in each dimension may appear black if a fractional number of pixels are left over. It can be removed but has been left to preserve total counts before and after binning.dtype ({None, numpy.dtype, "same"}) – Specify the dtype of the output. If None, the dtype will be determined by the behaviour of
numpy.sum()
, if “same”, the dtype will be kept the same. Default is None.out (
BaseSignal
(or subclasses) orNone
) – IfNone
, a new Signal is created with the result of the operation and returned (default). If a Signal is passed, it is used to receive the output of the operation, and nothing is returned.
- Returns:
s – The resulting cropped signal.
- Return type:
BaseSignal
(or subclass)- Raises:
NotImplementedError – If trying to rebin over a non-uniform axis.
Examples
>>> spectrum = hs.signals.EDSTEMSpectrum(np.ones([4, 4, 10])) >>> spectrum.data[1, 2, 9] = 5 >>> print(spectrum) <EDXTEMSpectrum, title: dimensions: (4, 4|10)> >>> print ('Sum = ', sum(sum(sum(spectrum.data)))) Sum = 164.0
>>> scale = [2, 2, 5] >>> test = spectrum.rebin(scale) >>> print(test) <EDSTEMSpectrum, title: dimensions (2, 2|2)> >>> print('Sum = ', sum(sum(sum(test.data)))) Sum = 164.0
>>> s = hs.signals.Signal1D(np.ones((2, 5, 10), dtype=np.uint8) >>> print(s) <Signal1D, title: , dimensions: (5, 2|10)> >>> print(s.data.dtype) uint8
Use dtype=np.unit16 to specify a dtype
>>> s2 = s.rebin(scale=(5, 2, 1), dtype=np.uint16) >>> print(s2.data.dtype) uint16
Use dtype=”same” to keep the same dtype
>>> s3 = s.rebin(scale=(5, 2, 1), dtype="same") >>> print(s3.data.dtype) uint8
By default dtype=None, the dtype is determined by the behaviour of numpy.sum, in this case, unsigned integer of the same precision as the platform interger
>>> s4 = s.rebin(scale=(5, 2, 1)) >>> print(s4.data.dtype) uint64
- rechunk(nav_chunks='auto', sig_chunks=-1, inplace=True, **kwargs)
Rechunks the data using the same rechunking formula from Dask expect that the navigation and signal chunks are defined seperately. Note, for most functions sig_chunks should remain
None
so that it spans the entire signal axes.- Parameters:
nav_chunks ({tuple, int, "auto", None}) – The navigation block dimensions to create. -1 indicates the full size of the corresponding dimension. Default is “auto” which automatically determines chunk sizes.
sig_chunks ({tuple, int, "auto", None}) – The signal block dimensions to create. -1 indicates the full size of the corresponding dimension. Default is -1 which automatically spans the full signal dimension
**kwargs (dict) – Any other keyword arguments for
dask.array.rechunk()
.
- valuemax(axis, out=None, rechunk=True)
Returns a signal with the value of coordinates of the maximum along an axis.
- Parameters:
axis (
int
,str
, orDataAxis
) – The axis can be passed directly, or specified using the index of the axis in the Signal’s axes_manager or the axis name.out (
BaseSignal
(or subclasses) orNone
) – IfNone
, a new Signal is created with the result of the operation and returned (default). If a Signal is passed, it is used to receive the output of the operation, and nothing is returned.rechunk (bool) – Only has effect when operating on lazy signal. If
True
(default), the data may be automatically rechunked before performing this operation.
- Returns:
s – A new Signal containing the calibrated coordinate values of the maximum along the specified axis.
- Return type:
BaseSignal
(or subclasses)
Examples
>>> import numpy as np >>> s = BaseSignal(np.random.random((64,64,1024))) >>> s.data.shape (64,64,1024) >>> s.valuemax(-1).data.shape (64,64)
- valuemin(axis, out=None, rechunk=True)
Returns a signal with the value of coordinates of the minimum along an axis.
- Parameters:
axis (
int
,str
, orDataAxis
) – The axis can be passed directly, or specified using the index of the axis in the Signal’s axes_manager or the axis name.out (
BaseSignal
(or subclasses) orNone
) – IfNone
, a new Signal is created with the result of the operation and returned (default). If a Signal is passed, it is used to receive the output of the operation, and nothing is returned.rechunk (bool) – Only has effect when operating on lazy signal. If
True
(default), the data may be automatically rechunked before performing this operation.
- Returns:
s – A new Signal containing the calibrated coordinate values of the minimum along the specified axis.
- Return type:
BaseSignal
(or subclasses)
Get the slice necessary to get the dask data chunk containing the navigation indices.
- Parameters:
navigation_indices (iterable) –
chunks (iterable) –
- Returns:
chunk_slice
- Return type:
list of slices
Examples
Making all the variables
>>> import dask.array as da >>> from hyperspy._signals.lazy import _get_navigation_dimension_chunk_slice >>> data = da.random.random((128, 128, 256, 256), chunks=(32, 32, 32, 32)) >>> s = hs.signals.Signal2D(data).as_lazy() >>> sig_dim = s.axes_manager.signal_dimension >>> nav_chunks = s.data.chunks[:-sig_dim] >>> navigation_indices = s.axes_manager._getitem_tuple[:-sig_dim]
The navigation index here is (0, 0), giving us the slice which contains this index.
>>> chunk_slice = _get_navigation_dimension_chunk_slice(navigation_indices, nav_chunks) >>> print(chunk_slice) (slice(0, 32, None), slice(0, 32, None)) >>> data_chunk = data[chunk_slice]
Moving the navigator to a new position, by directly setting the indices. Normally, this is done by moving the navigator while plotting the data. Note the “inversion” of the axes here: the indices is given in (x, y), while the chunk_slice is given in (y, x).
>>> s.axes_manager.indices = (128, 70) >>> navigation_indices = s.axes_manager._getitem_tuple[:-sig_dim] >>> chunk_slice = _get_navigation_dimension_chunk_slice(navigation_indices, nav_chunks) >>> print(chunk_slice) (slice(64, 96, None), slice(96, 128, None)) >>> data_chunk = data[chunk_slice]
- hyperspy._signals.lazy._reshuffle_mixed_blocks(array, ndim, sshape, nav_chunks)
Reshuffles dask block-shuffled array
- hyperspy._signals.lazy.to_array(thing, chunks=None)
Accepts BaseSignal, dask or numpy arrays and always produces either numpy or dask array.
- Parameters:
thing ({BaseSignal, dask.array.Array, numpy.ndarray}) – the thing to be converted
chunks ({None, tuple of tuples}) – If None, the returned value is a numpy array. Otherwise returns dask array with the chunks as specified.
- Returns:
res
- Return type:
{numpy.ndarray, dask.array.Array}