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.