autolens.Mask2D¶

class autolens.Mask2D(shape, dtype=float, buffer=None, offset=0, strides=None, order=None)¶

__init__(*args, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

Methods

`all`([axis, out, keepdims])	Returns True if all elements evaluate to True.
`any`([axis, out, keepdims])	Returns True if any of the elements of a evaluate to True.
`argmax`([axis, out])	Return indices of the maximum values along the given axis.
`argmin`([axis, out])	Return indices of the minimum values along the given axis of a.
`argpartition`(kth[, axis, kind, order])	Returns the indices that would partition this array.
`argsort`([axis, kind, order])	Returns the indices that would sort this array.
`astype`(dtype[, order, casting, subok, copy])	Copy of the array, cast to a specified type.
`blurring_mask_from`(kernel_shape_native)	Returns a blurring mask, which represents all masked pixels whose light will be blurred into unmasked pixels via PSF convolution (see grid.Grid2D.blurring_grid_from).
`byteswap`([inplace])	Swap the bytes of the array elements
`choose`(choices[, out, mode])	Use an index array to construct a new array from a set of choices.
`circular`(shape_native, int], radius, …)	Returns a Mask2D (see Mask2D.__new__) where all False entries are within a circle of input radius.
`circular_annular`(shape_native, int], …)	Returns a Mask2D (see Mask2D.__new__) where all False entries are within an annulus of input inner radius and outer radius.
`circular_anti_annular`(shape_native, int], …)	Returns a Mask2D (see Mask2D.__new__) where all False entries are within an inner circle and second outer circle, forming an inverse annulus.
`clip`([min, max, out])	Return an array whose values are limited to `[min, max]`.
`compress`(condition[, axis, out])	Return selected slices of this array along given axis.
`conj`()	Complex-conjugate all elements.
`conjugate`()	Return the complex conjugate, element-wise.
`copy`([order])	Return a copy of the array.
`cumprod`([axis, dtype, out])	Return the cumulative product of the elements along the given axis.
`cumsum`([axis, dtype, out])	Return the cumulative sum of the elements along the given axis.
`diagonal`([offset, axis1, axis2])	Return specified diagonals.
`dot`(b[, out])	Dot product of two arrays.
`dump`(file)	Dump a pickle of the array to the specified file.
`dumps`()	Returns the pickle of the array as a string.
`elliptical`(shape_native, int], …)	Returns a Mask2D (see Mask2D.__new__) where all False entries are within an ellipse.
`elliptical_annular`(shape_native, int], …)	Returns a Mask2D (see Mask2D.__new__) where all False entries are within an elliptical annulus of input inner and outer scaled major-axis and centre.
`fill`(value)	Fill the array with a scalar value.
`flatten`([order])	Return a copy of the array collapsed into one dimension.
`from_fits`(file_path, pixel_scales, …)	Loads the image from a .fits file.
`from_pixel_coordinates`(shape_native, int], …)	Returns a Mask2D (see Mask2D.__new__) where all False entries are defined from an input list of list of pixel coordinates.
`getfield`(dtype[, offset])	Returns a field of the given array as a certain type.
`grid_pixel_centres_from`(grid_scaled_1d)	Convert a grid of (y,x) scaled coordinates to a grid of (y,x) pixel values.
`grid_pixel_indexes_from`(grid_scaled_1d)	Convert a grid of (y,x) scaled coordinates to a grid of (y,x) pixel 1D indexes.
`grid_pixels_from`(grid_scaled_1d)	Convert a grid of (y,x) scaled coordinates to a grid of (y,x) pixel values.
`grid_scaled_for_marching_squares_from`(…)
`grid_scaled_from`(grid_pixels_1d)	Convert a grid of (y,x) pixel coordinates to a grid of (y,x) scaled values.
`item`(*args)	Copy an element of an array to a standard Python scalar and return it.
`itemset`(*args)	Insert scalar into an array (scalar is cast to array’s dtype, if possible)
`manual`(mask, pixel_scales, Tuple[float, …)	Returns a Mask2D (see AbstractMask2D.__new__) by inputting the array values in 2D, for example:
`mask_new_sub_size_from`(mask[, sub_size])	Returns the mask on the same scaled coordinate system but with a sub-grid of an inputsub_size.
`max`([axis, out, keepdims, initial, where])	Return the maximum along a given axis.
`mean`([axis, dtype, out, keepdims])	Returns the average of the array elements along given axis.
`min`([axis, out, keepdims, initial, where])	Return the minimum along a given axis.
`newbyteorder`([new_order])	Return the array with the same data viewed with a different byte order.
`nonzero`()	Return the indices of the elements that are non-zero.
`output_to_fits`(file_path[, overwrite])	Write the 2D Mask to a .fits file.
`partition`(kth[, axis, kind, order])	Rearranges the elements in the array in such a way that the value of the element in kth position is in the position it would be in a sorted array.
`pixel_coordinates_2d_from`(scaled_coordinates_2d)
`prod`([axis, dtype, out, keepdims, initial, …])	Return the product of the array elements over the given axis
`ptp`([axis, out, keepdims])	Peak to peak (maximum - minimum) value along a given axis.
`put`(indices, values[, mode])	Set `a.flat[n] = values[n]` for all n in indices.
`ravel`([order])	Return a flattened array.
`repeat`(repeats[, axis])	Repeat elements of an array.
`rescaled_mask_from`(rescale_factor)
`reshape`(shape[, order])	Returns an array containing the same data with a new shape.
`resize`(new_shape[, refcheck])	Change shape and size of array in-place.
`resized_mask_from`(new_shape, pad_value)	Resized the array to a new shape and at a new origin.
`round`([decimals, out])	Return a with each element rounded to the given number of decimals.
`scaled_coordinates_2d_from`(pixel_coordinates_2d)
`searchsorted`(v[, side, sorter])	Find indices where elements of v should be inserted in a to maintain order.
`setfield`(val, dtype[, offset])	Put a value into a specified place in a field defined by a data-type.
`setflags`([write, align, uic])	Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY), respectively.
`sort`([axis, kind, order])	Sort an array in-place.
`squeeze`([axis])	Remove single-dimensional entries from the shape of a.
`std`([axis, dtype, out, ddof, keepdims])	Returns the standard deviation of the array elements along given axis.
`sum`([axis, dtype, out, keepdims, initial, where])	Return the sum of the array elements over the given axis.
`swapaxes`(axis1, axis2)	Return a view of the array with axis1 and axis2 interchanged.
`take`(indices[, axis, out, mode])	Return an array formed from the elements of a at the given indices.
`tobytes`([order])	Construct Python bytes containing the raw data bytes in the array.
`tofile`(fid[, sep, format])	Write array to a file as text or binary (default).
`tolist`()	Return the array as an `a.ndim`-levels deep nested list of Python scalars.
`tostring`([order])	A compatibility alias for tobytes, with exactly the same behavior.
`trace`([offset, axis1, axis2, dtype, out])	Return the sum along diagonals of the array.
`transpose`(*axes)	Returns a view of the array with axes transposed.
`trimmed_array_from`(padded_array, image_shape)	Map a padded 1D array of values to its original 2D array, trimming all edge values.
`unmasked`(shape_native, int], pixel_scales, …)	Create a mask where all pixels are False and therefore unmasked.
`unmasked_blurred_array_from`(padded_array, …)	For a padded grid and psf, compute an unmasked blurred image from an unmasked unblurred image.
`var`([axis, dtype, out, ddof, keepdims])	Returns the variance of the array elements, along given axis.
`view`([dtype][, type])	New view of array with the same data.

Attributes

`T`	The transposed array.
`base`	Base object if memory is from some other object.
`border_1d_indexes`	The indicies of the mask’s border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
`border_2d_indexes`	The indicies of the mask’s border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
`border_grid_1d`	The indicies of the mask’s border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
`border_grid_sub_1`	The indicies of the mask’s border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
`border_mask`	The indicies of the mask’s border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
`central_pixel_coordinates`
`central_scaled_coordinates`
`ctypes`	An object to simplify the interaction of the array with the ctypes module.
`data`	Python buffer object pointing to the start of the array’s data.
`dimensions`
`dtype`	Data-type of the array’s elements.
`edge_1d_indexes`	The indicies of the mask’s edge pixels, where an edge pixel is any unmasked pixel on its edge (next to at least one pixel with a True value).
`edge_2d_indexes`	The indicies of the mask’s edge pixels, where an edge pixel is any unmasked pixel on its edge (next to at least one pixel with a True value).
`edge_buffed_mask`
`edge_grid_sub_1`	The indicies of the mask’s border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
`edge_mask`	The indicies of the mask’s border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
`extent`
`flags`	Information about the memory layout of the array.
`flat`	A 1-D iterator over the array.
`imag`	The imaginary part of the array.
`is_all_false`	Returns False if all pixels in a mask are False, else returns True.
`is_all_true`	Returns True if all pixels in a mask are True, else returns False.
`itemsize`	Length of one array element in bytes.
`mask_centre`
`mask_sub_1`	Returns the mask on the same scaled coordinate system but with a sub-grid of sub_size.
`masked_grid`
`masked_grid_sub_1`
`native_index_for_slim_index`	A 1D array of mappings between every unmasked pixel and its 2D pixel coordinates.
`nbytes`	Total bytes consumed by the elements of the array.
`ndim`	Number of array dimensions.
`pixel_scale`	For a mask with dimensions two or above check that are pixel scales are the same, and if so return this single value as a float.
`pixel_scales`
`pixels_in_mask`	The total number of unmasked pixels (values are False) in the mask.
`real`	The real part of the array.
`scaled_maxima`
`scaled_minima`
`shape`	Tuple of array dimensions.
`shape_native`
`shape_native_masked_pixels`	The (y,x) shape corresponding to the extent of unmasked pixels that go vertically and horizontally across the mask.
`shape_native_scaled`
`shape_slim`	The 1D shape of the mask, which is equivalent to the total number of unmasked pixels in the mask.
`size`	Number of elements in the array.
`slim_index_for_sub_slim_index`	A property that is only computed once per instance and then replaces itself with an ordinary attribute.
`strides`	Tuple of bytes to step in each dimension when traversing an array.
`sub_border_flat_indexes`	A property that is only computed once per instance and then replaces itself with an ordinary attribute.
`sub_fraction`	The fraction of the area of a pixel every sub-pixel contains.
`sub_length`	The total number of sub-pixels in a give pixel,
`sub_mask`
`sub_mask_index_for_sub_mask_1d_index`	A property that is only computed once per instance and then replaces itself with an ordinary attribute.
`sub_pixels_in_mask`	The total number of unmasked sub-pixels (values are False) in the mask.
`sub_shape_native`
`sub_shape_slim`	The 1D shape of the mask’s sub-grid, which is equivalent to the total number of unmasked pixels in the mask.
`unmasked_grid_sub_1`	The scaled-grid of (y,x) coordinates of every pixel.
`unmasked_mask`	The indicies of the mask’s border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
`zoom_centre`
`zoom_mask_unmasked`	The scaled-grid of (y,x) coordinates of every pixel.
`zoom_offset_pixels`
`zoom_offset_scaled`
`zoom_region`	The zoomed rectangular region corresponding to the square encompassing all unmasked values.
`zoom_shape_native`

classmethod manual(mask: numpy.ndarray, pixel_scales: Union[float, Tuple[float, float]], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), invert: bool = False) → autoarray.mask.mask_2d.Mask2D¶

Returns a Mask2D (see AbstractMask2D.__new__) by inputting the array values in 2D, for example:

mask=np.array([[False, False],: [True, False]])
mask=[[False, False],: [True, False]]

Parameters:

or list (mask) – The bool values of the mask input as an np.ndarray of shape [total_y_pixels, total_x_pixels] or a list of lists.
pixel_scales – The (y,x) scaled units to pixel units conversion factors of every pixel. If this is input as a float, it is converted to a (float, float) structure.
sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin – The (y,x) scaled units origin of the mask’s coordinate system.
invert (bool) – If True, the bool’s of the input mask are inverted, for example False’s become True and visa versa.

classmethod unmasked(shape_native: Tuple[int, int], pixel_scales: Union[float, Tuple[float, float]], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), invert: bool = False) → autoarray.mask.mask_2d.Mask2D¶

Create a mask where all pixels are False and therefore unmasked.

Parameters:

shape_native – The 2D shape of the mask that is created.
pixel_scales – The (y,x) scaled units to pixel units conversion factors of every pixel. If this is input as a float, it is converted to a (float, float) structure.
sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin – The (y,x) scaled units origin of the mask’s coordinate system.
invert (bool) – If True, the bool’s of the input mask are inverted, for example False’s become True and visa versa.

classmethod circular(shape_native: Tuple[int, int], radius: float, pixel_scales: Union[float, Tuple[float, float]], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), centre: Tuple[float, float] = (0.0, 0.0), invert: bool = False) → autoarray.mask.mask_2d.Mask2D¶

Returns a Mask2D (see Mask2D.__new__) where all False entries are within a circle of input radius.

The radius and centre are both input in scaled units.

Parameters:

shape_native – The (y,x) shape of the mask in units of pixels.
radius – The radius in scaled units of the circle within which pixels are False and unmasked.
pixel_scales – The (y,x) scaled units to pixel units conversion factors of every pixel. If this is input as a float, it is converted to a (float, float) structure.
sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin – The (y,x) scaled units origin of the mask’s coordinate system.
centre – The (y,x) scaled units centre of the circle used to mask pixels.
invert (bool) – If True, the bool’s of the input mask are inverted, for example False’s become True and visa versa.

classmethod circular_annular(shape_native: Tuple[int, int], inner_radius: float, outer_radius: float, pixel_scales: Union[float, Tuple[float, float]], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), centre: Tuple[float, float] = (0.0, 0.0), invert: bool = False) → autoarray.mask.mask_2d.Mask2D¶

Returns a Mask2D (see Mask2D.__new__) where all False entries are within an annulus of input inner radius and outer radius.

The inner_radius, outer_radius and centre are all input in scaled units.

Parameters:

shape_native – The (y,x) shape of the mask in units of pixels.
inner_radius – The inner radius in scaled units of the annulus within which pixels are False and unmasked.
outer_radius – The outer radius in scaled units of the annulus within which pixels are False and unmasked.
pixel_scales – The (y,x) scaled units to pixel units conversion factors of every pixel. If this is input as a float, it is converted to a (float, float) structure.
sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin – The (y,x) scaled units origin of the mask’s coordinate system.
centre – The (y,x) scaled units centre of the annulus used to mask pixels.
invert (bool) – If True, the bool’s of the input mask are inverted, for example False’s become True and visa versa.

classmethod circular_anti_annular(shape_native: Tuple[int, int], inner_radius: float, outer_radius: float, outer_radius_2: float, pixel_scales: Union[float, Tuple[float, float]], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), centre: Tuple[float, float] = (0.0, 0.0), invert: bool = False) → autoarray.mask.mask_2d.Mask2D¶

Returns a Mask2D (see Mask2D.__new__) where all False entries are within an inner circle and second outer circle, forming an inverse annulus.

The inner_radius, outer_radius, outer_radius_2 and centre are all input in scaled units.

Parameters:

shape_native – The (y,x) shape of the mask in units of pixels.
inner_radius – The inner radius in scaled units of the annulus within which pixels are False and unmasked.
outer_radius – The first outer radius in scaled units of the annulus within which pixels are True and masked.
outer_radius_2 – The second outer radius in scaled units of the annulus within which pixels are False and unmasked and outside of which all entries are True and masked.
pixel_scales – The (y,x) scaled units to pixel units conversion factors of every pixel. If this is input as a float, it is converted to a (float, float) structure.
sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin – The (y,x) scaled units origin of the mask’s coordinate system.
centre – The (y,x) scaled units centre of the anti-annulus used to mask pixels.
invert (bool) – If True, the bool’s of the input mask are inverted, for example False’s become True and visa versa.

classmethod elliptical(shape_native: Tuple[int, int], major_axis_radius: float, axis_ratio: float, angle: float, pixel_scales: Union[float, Tuple[float, float]], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), centre: Tuple[float, float] = (0.0, 0.0), invert: bool = False) → autoarray.mask.mask_2d.Mask2D¶

Returns a Mask2D (see Mask2D.__new__) where all False entries are within an ellipse.

The major_axis_radius, and centre are all input in scaled units.

Parameters:

shape_native – The (y,x) shape of the mask in units of pixels.
major_axis_radius – The major-axis in scaled units of the ellipse within which pixels are unmasked.
axis_ratio – The axis-ratio of the ellipse within which pixels are unmasked.
angle –

The rotation angle of the ellipse within which pixels are unmasked, (counter-clockwise from the positive

x-axis).
pixel_scales – The (y,x) scaled units to pixel units conversion factors of every pixel. If this is input as a float, it is converted to a (float, float) structure.
sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin – The (y,x) scaled units origin of the mask’s coordinate system.
centre – The (y,x) scaled units centred of the ellipse used to mask pixels.
invert (bool) – If True, the bool’s of the input mask are inverted, for example False’s become True and visa versa.

classmethod elliptical_annular(shape_native: Tuple[int, int], inner_major_axis_radius: float, inner_axis_ratio: float, inner_phi: float, outer_major_axis_radius: float, outer_axis_ratio: float, outer_phi: float, pixel_scales: Union[float, Tuple[float, float]], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), centre: Tuple[float, float] = (0.0, 0.0), invert: bool = False) → autoarray.mask.mask_2d.Mask2D¶

Returns a Mask2D (see Mask2D.__new__) where all False entries are within an elliptical annulus of input inner and outer scaled major-axis and centre.

The outer_major_axis_radius, inner_major_axis_radius and centre are all input in scaled units.

Parameters:

(int, int) (shape_native) – The (y,x) shape of the mask in units of pixels.
pixel_scales – The scaled units to pixel units conversion factor of each pixel.
inner_major_axis_radius – The major-axis in scaled units of the inner ellipse within which pixels are masked.
inner_axis_ratio – The axis-ratio of the inner ellipse within which pixels are masked.
inner_phi – The rotation angle of the inner ellipse within which pixels are masked, (counter-clockwise from the positive x-axis).
outer_major_axis_radius – The major-axis in scaled units of the outer ellipse within which pixels are unmasked.
outer_axis_ratio – The axis-ratio of the outer ellipse within which pixels are unmasked.
outer_phi – The rotation angle of the outer ellipse within which pixels are unmasked, (counter-clockwise from the positive x-axis).
sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin – The (y,x) scaled units origin of the mask’s coordinate system.
centre – The (y,x) scaled units centre of the elliptical annuli used to mask pixels.
invert (bool) – If True, the bool’s of the input mask are inverted, for example False’s become True and visa versa.

classmethod from_pixel_coordinates(shape_native: Tuple[int, int], pixel_coordinates: [[<class 'int'>, <class 'int'>]], pixel_scales: Union[float, Tuple[float, float]], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), buffer: int = 0, invert: bool = False) → autoarray.mask.mask_2d.Mask2D¶

Returns a Mask2D (see Mask2D.__new__) where all False entries are defined from an input list of list of pixel coordinates.

These may be buffed via an input buffer, whereby all entries in all 8 neighboring directions by this amount.

Parameters:

(int, int) (shape_native) – The (y,x) shape of the mask in units of pixels.
pixel_coordinates ([[int, int]]) – The input lists of 2D pixel coordinates where False entries are created.
pixel_scales – The scaled units to pixel units conversion factor of each pixel.
sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin – The (y,x) scaled units origin of the mask’s coordinate system.
buffer – All input pixel_coordinates are buffed with False entries in all 8 neighboring directions by this amount.
invert (bool) – If True, the bool’s of the input mask are inverted, for example False’s become True and visa versa.

classmethod from_fits(file_path: str, pixel_scales: Union[float, Tuple[float, float]], hdu: int = 0, sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), resized_mask_shape: Tuple[int, int] = None) → autoarray.mask.mask_2d.Mask2D¶

Loads the image from a .fits file.

Parameters:

file_path (str) – The full path of the fits file.
hdu – The HDU number in the fits file containing the image image.
or (float, float) (pixel_scales) – The scaled units to pixel units conversion factor of each pixel.
sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin – The (y,x) scaled units origin of the mask’s coordinate system.