NDData is based on numpy.ndarray-like data with additional meta attributes:

  • meta for general metadata

  • unit represents the physical unit of the data

  • uncertainty for the uncertainty of the data

  • mask indicates invalid points in the data

  • wcs represents the relationship between the data grid and world coordinates

  • psf holds an image representation of the point spread function (PSF)

Each of these attributes can be set during initialization or directly on the instance. Only the data cannot be directly set after creating the instance.


The data is the base of NDData and is required to be numpy.ndarray-like. It is the only property that is required to create an instance and it cannot be directly set on the instance.


To create an instance:

>>> import numpy as np
>>> from astropy.nddata import NDData
>>> array = np.array([[0, 1, 0], [1, 0, 1], [0, 1, 0]])
>>> ndd = NDData(array)
>>> ndd
NDData([[0, 1, 0],
        [1, 0, 1],
        [0, 1, 0]])

And access by the data attribute:

>>> ndd.data
array([[0, 1, 0],
       [1, 0, 1],
       [0, 1, 0]])

As already mentioned, it is not possible to set the data directly. So ndd.data = np.arange(9) will raise an exception. But the data can be modified in place:

>>> ndd.data[1,1] = 100
>>> ndd.data
array([[  0,   1,   0],
       [  1, 100,   1],
       [  0,   1,   0]])

Data During Initialization#

During initialization it is possible to provide data that is not a numpy.ndarray but convertible to one.


To provide data that is convertible to a numpy.ndarray, you can pass a list containing numerical values:

>>> alist = [1, 2, 3, 4]
>>> ndd = NDData(alist)
>>> ndd.data  # data will be a numpy-array:
array([1, 2, 3, 4])

A nested list or tuple is possible, but if these contain non-numerical values the conversion might fail.

Besides input that is convertible to such an array, you can also use the data parameter to pass implicit additional information. For example, if the data is another NDData object it implicitly uses its properties:

>>> ndd = NDData(ndd, unit = 'm')
>>> ndd2 = NDData(ndd)
>>> ndd2.data  # It has the same data as ndd
array([1, 2, 3, 4])
>>> ndd2.unit  # but it also has the same unit as ndd

Another possibility is to use a Quantity as a data parameter:

>>> import astropy.units as u
>>> quantity = np.ones(3) * u.cm  # this will create a Quantity
>>> ndd3 = NDData(quantity)
>>> ndd3.data  
array([1., 1., 1.])
>>> ndd3.unit

Or a numpy.ma.MaskedArray:

>>> masked_array = np.ma.array([5,10,15], mask=[False, True, False])
>>> ndd4 = NDData(masked_array)
>>> ndd4.data
array([ 5, 10, 15])
>>> ndd4.mask
array([False,  True, False]...)

If such an implicitly passed property conflicts with an explicit parameter, the explicit parameter will be used and an info message will be issued:

>>> quantity = np.ones(3) * u.cm
>>> ndd6 = NDData(quantity, unit='m')
INFO: overwriting Quantity's current unit with specified unit. [astropy.nddata.nddata]
>>> ndd6.data  
array([0.01, 0.01, 0.01])
>>> ndd6.unit

The unit of the Quantity is being ignored and the unit is set to the explicitly passed one.

It might be possible to pass other classes as a data parameter as long as they have the properties shape, dtype, __getitem__, and __array__.

The purpose of this mechanism is to allow considerable flexibility in the objects used to store the data while providing a useful default (numpy array).


The mask is being used to indicate if data points are valid or invalid. NDData does not restrict this mask in any way but it is expected to follow the numpy.ma.MaskedArray convention in that the mask:

  • Returns True for data points that are considered invalid.

  • Returns False for those points that are valid.


One possibility is to create a mask by using numpy’s comparison operators:

>>> array = np.array([0, 1, 4, 0, 2])

>>> mask = array == 0  # Mask points containing 0
>>> mask
array([ True, False, False,  True, False]...)

>>> other_mask = array > 1  # Mask points with a value greater than 1
>>> other_mask
array([False, False,  True, False,  True]...)

And initialize the NDData instance using the mask parameter:

>>> ndd = NDData(array, mask=mask)
>>> ndd.mask
array([ True, False, False,  True, False]...)

Or by replacing the mask:

>>> ndd.mask = other_mask
>>> ndd.mask
array([False, False,  True, False,  True]...)

There is no requirement that the mask actually be a numpy array; for example, a function which evaluates a mask value as needed is acceptable as long as it follows the convention that True indicates a value that should be ignored.


The unit represents the unit of the data values. It is required to be Unit-like or a string that can be converted to such a Unit:

>>> import astropy.units as u
>>> ndd = NDData([1, 2, 3, 4], unit="meter")  # using a string
>>> ndd.unit

Setting the unit on an instance is not possible.


The uncertainty represents an arbitrary representation of the error of the data values. To indicate which kind of uncertainty representation is used, the uncertainty should have an uncertainty_type property. If no such property is found it will be wrapped inside a UnknownUncertainty.

The uncertainty_type should follow the StdDevUncertainty convention in that it returns a short string like "std" for an uncertainty given in standard deviation. Other examples are VarianceUncertainty and InverseVariance.


Like the other properties the uncertainty can be set during initialization:

>>> from astropy.nddata import StdDevUncertainty, InverseVariance
>>> array = np.array([10, 7, 12, 22])
>>> uncert = StdDevUncertainty(np.sqrt(array))
>>> ndd = NDData(array, uncertainty=uncert)
>>> ndd.uncertainty  
StdDevUncertainty([3.16227766, 2.64575131, 3.46410162, 4.69041576])

Or on the instance directly:

>>> other_uncert = StdDevUncertainty([2,2,2,2])
>>> ndd.uncertainty = other_uncert
>>> ndd.uncertainty
StdDevUncertainty([2, 2, 2, 2])

But it will print an info message if there is no uncertainty_type:

>>> ndd.uncertainty = np.array([5, 1, 2, 10])
INFO: uncertainty should have attribute uncertainty_type. [astropy.nddata.nddata]
>>> ndd.uncertainty
UnknownUncertainty([ 5,  1,  2, 10])

It is also possible to convert between uncertainty types:

>>> uncert.represent_as(InverseVariance)
InverseVariance([0.1       , 0.14285714, 0.08333333, 0.04545455])


The wcs should contain a mapping from the gridded data to world coordinates. There are no restrictions placed on the property currently but it may be restricted to an WCS object or a more generalized WCS object in the future.


Like the unit the wcs cannot be set on an instance.


The meta property contains all further meta information that does not fit any other property.


If the meta property is given it must be dict-like:

>>> ndd = NDData([1,2,3], meta={'observer': 'myself'})
>>> ndd.meta
{'observer': 'myself'}

dict-like means it must be a mapping from some keys to some values. This also includes Header objects:

>>> from astropy.io import fits
>>> header = fits.Header()
>>> header['observer'] = 'Edwin Hubble'
>>> ndd = NDData(np.zeros([10, 10]), meta=header)
>>> ndd.meta['observer']
'Edwin Hubble'

If the meta property is not provided or explicitly set to None, it will default to an empty collections.OrderedDict:

>>> ndd.meta = None
>>> ndd.meta

>>> ndd = NDData([1,2,3])
>>> ndd.meta

The meta object therefore supports adding or updating these values:

>>> ndd.meta['exposure_time'] = 340.
>>> ndd.meta['filter'] = 'J'

Elements of the metadata dictionary can be set to any valid Python object:

>>> ndd.meta['history'] = ['calibrated', 'aligned', 'flat-fielded']

Initialization with Copy#

The default way to create an NDData instance is to try saving the parameters as references to the original rather than as copy. Sometimes this is not possible because the internal mechanics do not allow for this.


If the data is a list then during initialization this is copied while converting to a ndarray. But it is also possible to enforce copies during initialization by setting the copy parameter to True:

>>> array = np.array([1, 2, 3, 4])
>>> ndd = NDData(array)
>>> ndd.data[2] = 10
>>> array[2]  # Original array has changed

>>> ndd2 = NDData(array, copy=True)
>>> ndd2.data[2] = 3
>>> array[2]  # Original array hasn't changed.


In some cases setting copy=True will copy the data twice. Known cases are if the data is a list or tuple.

Collapsing an NDData object along one or more axes#

A common operation on an ndarray is to take the sum, mean, maximum, or minimum along one or more axes, reducing the dimensions of the output. These four operations are implemented on NDData with appropriate propagation of uncertainties, masks, and units.

For example, let’s work on the following data with a mask, unit, and (uniform) uncertainty:

>>> import numpy as np
>>> import astropy.units as u
>>> from astropy.nddata import NDDataArray, StdDevUncertainty
>>> data = [
...     [1, 2, 3],
...     [2, 3, 4]
... ]
>>> mask = [
...     [True, False, False],
...     [False, False, False]
... ]
>>> uncertainty = StdDevUncertainty(np.ones_like(data))
>>> nddata = NDDataArray(data=data, uncertainty=uncertainty, mask=mask, unit='m')

The sum along axis 1 gives one result per row:

>>> sum_axis_1 = nddata.sum(axis=1)  # this is a new NDDataArray
>>> print(np.asanyarray(sum_axis_1))  # this converts data to a numpy masked array. doctest: +FLOAT_CMP
[-- 9.0]
>>> print(sum_axis_1.uncertainty)  
StdDevUncertainty([1.41421356, 1.73205081])

The result has one masked value derived from the logical OR of the original mask along axis=1. The uncertainties are the square-root of the sum of the squares of the input uncertainties. Since the original uncertainties were all unity, the result is the square root of the number of unmasked data entries, \([\sqrt{2},\,\sqrt{3}]\).

We can similarly take the mean along axis=1:

>>> mean_axis_1 = nddata.mean(axis=1)
>>> print(np.asanyarray(mean_axis_1))  
[2.5 3.0]
>>> print(mean_axis_1.uncertainty)  
StdDevUncertainty([0.70710678, 0.57735027])

The result is the mean of the values where mask==False, and in this example, the result would only have mask==True if an entire row was masked. Since the uncertainties were given as StdDevUncertainty, the propagated uncertainties decrease proportional to the number of unmasked measurements in each row, following \([2^{-1/2},\,3^{-1/2}]\).

There’s no single, correct way of defining the uncertainties associated with the min or max of a set of measurements, so NDData resists the temptation to guess, and returns the minimum data value along the axis/axes, and the propagated mask, but no uncertainties:

>>> min_axis_1 = nddata.min(axis=1)
>>> print(np.asanyarray(min_axis_1))  
[2.0 2.0]
>>> print(min_axis_1.uncertainty)

For some use cases, it may be helpful to return the uncertainty at the same index as the minimum/maximum data value, so that the original data retains its uncertainty. You can get this behavior with:

>>> min_axis_1 = nddata.min(axis=1, propagate_uncertainties=True)

>>> print(np.asanyarray(min_axis_1))  
[2.0 2.0]
>>> print(min_axis_1.uncertainty)  
StdDevUncertainty([1, 1])

Finally, in some cases it may be useful to do perform a collapse operation only on the unmasked values, and only return a masked result when all of the input values are masked. If we refer back to the first example in this section, we see that the underlying data attribute has been summed over all values, including masked ones:

>>> sum_axis_1  
NDDataArray([——, 9.], unit='m')

where the first data element is masked. We can instead get the sum for only unmasked values with the operation_ignores_mask option:

>>> nddata.sum(axis=1, operation_ignores_mask=True)
NDDataArray([5, 9], unit='m')

Converting NDData to Other Classes#

There is limited support to convert a NDData instance to other classes. In the process some properties might be lost.

>>> data = np.array([1, 2, 3, 4])
>>> mask = np.array([True, False, False, True])
>>> unit = 'm'
>>> ndd = NDData(data, mask=mask, unit=unit)


Converting the data to an array:

>>> array = np.asarray(ndd.data)
>>> array
array([1, 2, 3, 4])

Though using np.asarray is not required, in most cases it will ensure that the result is always a numpy.ndarray


Converting the data and mask to a MaskedArray:

>>> masked_array = np.ma.array(ndd.data, mask=ndd.mask)
>>> masked_array
masked_array(data=[--, 2, 3, --],
             mask=[ True, False, False,  True],


Converting the data and unit to a Quantity:

>>> quantity = u.Quantity(ndd.data, unit=ndd.unit)
>>> quantity  
<Quantity [1., 2., 3., 4.] m>


Converting the data, unit, and mask to a MaskedQuantity:

>>> from astropy.utils.masked import Masked
>>> Masked(u.Quantity(ndd.data, ndd.unit), ndd.mask)  
<MaskedQuantity [——, 2., 3., ——] m>