autolens.Mask2D

class autolens.Mask2D(mask: ndarray, pixel_scales: Union[Tuple[float], Tuple[float, float], float], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0), *args, **kwargs)

__init__(*args, **kwargs)

Methods

__init__(*args, **kwargs)
all([axis, out, keepdims, where])	Returns True if all elements evaluate to True.
any([axis, out, keepdims, where])	Returns True if any of the elements of a evaluate to True.
argmax([axis, out, keepdims])	Return indices of the maximum values along the given axis.
argmin([axis, out, keepdims])	Return indices of the minimum values along the given axis.
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, radius, pixel_scales)	Returns a Mask2D (see Mask2D.__new__) where all False entries are within a circle of input radius.
circular_annular(shape_native, inner_radius, ...)	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, ...[, ...])	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
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, major_axis_radius, ...)	Returns a Mask2D (see Mask2D.__new__) where all False entries are within an ellipse.
elliptical_annular(shape_native, ...[, ...])	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[, hdu, ...])	Loads the image from a .fits file.
from_pixel_coordinates(shape_native, ...[, ...])	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[, sub_size, ...])	Returns a Mask2D (see Mask2D.__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, where])	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, respectively.
sort([axis, kind, order])	Sort an array in-place.
squeeze([axis])	Remove axes of length one from a.
std([axis, dtype, out, ddof, keepdims, where])	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, 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, where])	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 indexes of the mask's border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
border_2d_indexes	The indexes of the mask's border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
border_grid_1d	The indexes 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 indexes of the mask's border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
border_mask	The indexes 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 indexes 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 indexes 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 indexes of the mask's border pixels, where a border pixel is any unmasked pixel on an exterior edge e.g.
edge_mask	The indexes 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_1d_indexes	The 1D indexes of the mask's unmasked pixels (e.g.
masked_grid
masked_grid_sub_1
native	Returns the data structure in its native format which contains all unmaksed values to the native dimensions.
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	The (y,x) 2D shape of the mask in scaled units, computed from the 2D shape (units pixels) and the pixel_scales (units scaled/pixels) conversion factor.
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_1d_indexes	The 1D indexes of the mask's unmasked pixels (e.g.
unmasked_grid_sub_1	The scaled-grid of (y,x) coordinates of every pixel.
unmasked_mask	The indexes 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