autolens.Mask2D#

class autolens.Mask2D(shape, dtype=float, buffer=None, offset=0, strides=None, order=None)[source]#
__init__(*args, **kwargs)#

Initialize self. See help(type(self)) for accurate signature.

Methods

__init__(*args, **kwargs)

Initialize self.

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, 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(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, 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])

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, 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

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_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