autolens.Grid2D

class autolens.Grid2D(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_grid_from(mask, …) Setup a blurring-grid from a mask, where a blurring grid consists of all pixels that are masked (and therefore have their values set to (0.0, 0.0)), but are close enough to the unmasked pixels that their values will be convolved into the unmasked those pixels.
blurring_grid_via_kernel_shape_from(…) Returns the blurring grid from a grid, via an input 2D kernel shape.
bounding_box(bounding_box, shape_native, …) Create a Grid2D (see Grid2D.__new__) from an input bounding box with coordinates [y_min, y_max, x_min, x_max], where the shape_native is used to compute the (y,x) grid values within this bounding box.
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.
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.
distances_to_coordinate(coordinate, …) Returns the distance of every coordinate on the grid from an input (y,x) coordinate.
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.
extent_with_buffer(buffer) The extent of the grid in scaled units returned as a list [x_min, x_max, y_min, y_max], where all values are buffed such that their extent is further than the grid’s extent..
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, float], …) Create a Grid2D (see Grid2D.__new__) from a mask, where only unmasked pixels are included in the grid (if the grid is represented in its native 2D masked values are (0.0, 0.0)).
from_mask(mask) Create a Grid2D (see Grid2D.__new__) from a mask, where only unmasked pixels are included in the grid (if the grid is represented in its native 2D masked values are (0.0, 0.0)).
getfield(dtype[, offset]) Returns a field of the given array as a certain type.
grid_2d_radial_projected_from(centre, …) Determine a projected radial grid of points from a 2D region of coordinates defined by an extent [xmin, xmax, ymin, ymax] and with a (y,x) centre.
grid_via_deflection_grid_from(deflection_grid) Returns a new Grid2D from this grid, where the (y,x) coordinates of this grid have a grid of (y,x) values,
grid_with_coordinates_within_distance_removed(…) Remove all coordinates from this Grid2D which are within a certain distance of an input list of coordinates.
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)
load(file_path, filename)
manual(grid, List[T]], pixel_scales, float], …) Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in 1D or 2D, automatically determining whether to use the ‘manual_slim’ or ‘manual_native’ methods.
manual_mask(grid, List[T]], mask) Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in their native or slimmed format with their corresponding mask, automatically determining whether to use the ‘manual_slim’ or ‘manual_native’ methods.
manual_native(grid, List[T]], pixel_scales, …) Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in 2D, for example:
manual_slim(grid, List[T]], shape_native, …) Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in 1D, for example:
manual_yx_1d(y, List[T]], x, shape_native, …) Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates as 1D y and x values, for example:
manual_yx_2d(y, List[T]], x, List[T]], …) Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates as 2D y and x values, for example:
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) Output the grid to a .fits file.
padded_before_convolution_from(kernel_shape)
padded_grid_from(kernel_shape_native, float]) When the edge pixels of a mask are unmasked and a convolution is to occur, the signal of edge pixels will be ‘missing’ if the grid is used to evaluate the signal via an analytic function.
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.
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.
relocated_grid_from(grid) Relocate the coordinates of a grid to the border of this grid if they are outside the border, where the border is defined as all pixels at the edge of the grid’s mask (see mask._border_1d_indexes).
relocated_pixelization_grid_from(…) Relocate the coordinates of a pixelization grid to the border of this grid, see the method relocated_grid_from for a full description of grid relocation.
repeat(repeats[, axis]) Repeat elements of an array.
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_from(new_shape)
round([decimals, out]) Return a with each element rounded to the given number of decimals.
save(file_path, filename) Save the tracer by serializing it with pickle.
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.
squared_distances_to_coordinate(coordinate, …) Returns the squared distance of every coordinate on the grid from an input coordinate.
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.
structure_2d_from(result) Convert a result from an ndarray to an aa.Array2D or aa.Grid2D structure, where the conversion depends on type(result) as follows:
structure_2d_list_from(result_list) Convert a result from a list of ndarrays to a list of aa.Array2D or aa.Grid2D structure, where the conversion depends on type(result) as follows:
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_after_convolution_from(kernel_shape)
uniform(shape_native, float], pixel_scales, …) Create a Grid2D (see Grid2D.__new__) as a uniform grid of (y,x) values given an input shape_native and pixel_scales of the grid:
values_from(array_slim) Create a ValuesIrregular object from a 1D NumPy array of values of shape [total_coordinates].
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.
binned Convenience method to access the binned-up grid in its 1D representation, which is a Grid2D stored as an ndarray of shape [total_unmasked_pixels, 2].
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.
dtype Data-type of the array’s elements.
extent The extent of the grid in scaled units returned as an ndarray of the form [x_min, x_max, y_min, y_max].
flags Information about the memory layout of the array.
flat A 1-D iterator over the array.
flipped Return the grid as an ndarray of shape [total_unmasked_pixels, 2] with flipped values such that coordinates are given as (x,y) values.
imag The imaginary part of the array.
in_radians Return the grid as an ndarray where all (y,x) values are converted to Radians.
itemsize Length of one array element in bytes.
native Return a Grid2D where the data is stored in its native representation, which is an ndarray of shape [sub_size*total_y_pixels, sub_size*total_x_pixels, 2].
nbytes Total bytes consumed by the elements of the array.
ndim Number of array dimensions.
origin
pixel_scale
pixel_scales
real The real part of the array.
scaled_maxima The maximum values of the grid in scaled coordinates returned as a tuple (y_max, x_max).
scaled_minima The minium values of the grid in scaled coordinates returned as a tuple (y_min, x_min).
shape Tuple of array dimensions.
shape_native
shape_native_scaled The two dimensional shape of the grid in scaled units, computed by taking the minimum and maximum values of the grid.
shape_slim
size Number of elements in the array.
slim Return a Grid2D where the data is stored its slim representation, which is an ndarray of shape [total_unmasked_pixels * sub_size**2, 2].
strides Tuple of bytes to step in each dimension when traversing an array.
sub_border_grid A property that is only computed once per instance and then replaces itself with an ordinary attribute.
sub_shape_native
sub_shape_slim
sub_size
total_pixels
unmasked_grid
classmethod manual_slim(grid: Union[numpy.ndarray, List[T]], shape_native: Tuple[int, int], pixel_scales: Union[Tuple[float, float], float], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0)) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in 1D, for example:

grid=np.array([[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0]])

grid=[[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0]]

From 1D input the method cannot determine the 2D shape of the grid and its mask, thus the shape_native must be input into this method. The mask is setup as a unmasked Mask2D of shape_native.

Parameters:
  • or list (grid) – The (y,x) coordinates of the grid input as an ndarray of shape [total_unmasked_pixells*(sub_size**2), 2] or a list of lists.
  • shape_native – The 2D shape of the mask the grid is paired with.
  • 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-grid.
  • origin – The origin of the grid’s mask.
classmethod manual_native(grid: Union[numpy.ndarray, List[T]], pixel_scales: Union[Tuple[float, float], float], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0)) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in 2D, for example:

grid=np.ndarray([[[1.0, 1.0], [2.0, 2.0]],
[[3.0, 3.0], [4.0, 4.0]]])
grid=[[[1.0, 1.0], [2.0, 2.0]],
[[3.0, 3.0], [4.0, 4.0]]]

The 2D shape of the grid and its mask are determined from the input grid and the mask is setup as an unmasked Mask2D of shape_native.

Parameters:
  • or list (grid) – The (y,x) coordinates of the grid input as an ndarray of shape [total_y_coordinates*sub_size, total_x_pixel*sub_size, 2] 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-grid.
  • origin – The origin of the grid’s mask.
classmethod manual(grid: Union[numpy.ndarray, List[T]], pixel_scales: Union[Tuple[float, float], float], shape_native: Tuple[int, int] = None, sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0)) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in 1D or 2D, automatically determining whether to use the ‘manual_slim’ or ‘manual_native’ methods.

See the manual_slim and manual_native methods for examples.

Parameters:
  • or list (grid) – The (y,x) coordinates of the grid input as an ndarray of shape [total_unmasked_pixells*(sub_size**2), 2] or a list of lists.
  • shape_native – The 2D shape of the mask the grid is paired with.
  • 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-grid.
  • origin – The origin of the grid’s mask.
classmethod manual_mask(grid: Union[numpy.ndarray, List[T]], mask: autoarray.mask.mask_2d.Mask2D) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates in their native or slimmed format with their corresponding mask, automatically determining whether to use the ‘manual_slim’ or ‘manual_native’ methods.

See the manual_slim and manual_native methods for examples.

Parameters:
  • or list (grid) – The (y,x) coordinates of the grid input as an ndarray of shape [total_sub_coordinates, 2] or list of lists.
  • mask (Mask2D) – The 2D mask associated with the grid, defining the pixels each grid coordinate is paired with and originates from.
classmethod manual_yx_1d(y: Union[numpy.ndarray, List[T]], x: numpy.ndarray, shape_native: Tuple[int, int], pixel_scales: Union[Tuple[float, float], float], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0)) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates as 1D y and x values, for example:

y = np.array([1.0, 2.0, 3.0, 4.0]) x = np.array([1.0, 2.0, 3.0, 4.0]) y = [1.0, 2.0, 3.0, 4.0] x = [1.0, 2.0, 3.0, 4.0]

From 1D input the method cannot determine the 2D shape of the grid and its mask, thus the shape_native must be input into this method. The mask is setup as a unmasked Mask2D of shape_native.

Parameters:
  • or list (x) – The y coordinates of the grid input as an ndarray of shape [total_coordinates] or list.
  • or list – The x coordinates of the grid input as an ndarray of shape [total_coordinates] or list.
  • shape_native – The 2D shape of the mask the grid is paired with.
  • 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-grid.
  • origin – The origin of the grid’s mask.
classmethod manual_yx_2d(y: Union[numpy.ndarray, List[T]], x: Union[numpy.ndarray, List[T]], pixel_scales: Union[Tuple[float, float], float], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0)) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) by inputting the grid coordinates as 2D y and x values, for example:

y = np.array([[1.0, 2.0],
[3.0, 4.0]])
x = np.array([[1.0, 2.0],
[3.0, 4.0]])
y = [[1.0, 2.0],
[3.0, 4.0]]
x = [[1.0, 2.0],
[3.0, 4.0]]

The 2D shape of the grid and its mask are determined from the input grid and the mask is setup as an unmasked Mask2D of shape_native.

Parameters:
  • or list (x) – The y coordinates of the grid input as an ndarray of shape [total_coordinates] or list.
  • or list – The x coordinates of the grid input as an ndarray of shape [total_coordinates] or list.
  • 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-grid.
  • origin – The origin of the grid’s mask.
classmethod uniform(shape_native: Tuple[float, float], pixel_scales: Union[float, Tuple[float, float]], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0)) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) as a uniform grid of (y,x) values given an input shape_native and pixel_scales of the grid:

Parameters:
  • shape_native – The 2D shape of the uniform grid and the mask that it is paired with.
  • 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) tuple.
  • sub_size – The size (sub_size x sub_size) of each unmasked pixels sub-grid.
  • origin – The origin of the grid’s mask.
classmethod bounding_box(bounding_box: numpy.ndarray, shape_native: Tuple[int, int], sub_size: int = 1, buffer_around_corners: bool = False) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) from an input bounding box with coordinates [y_min, y_max, x_min, x_max], where the shape_native is used to compute the (y,x) grid values within this bounding box.

If buffer_around_corners=True, the grid’s (y,x) values fully align with the input bounding box values. This means the mask’s edge pixels extend beyond the bounding box by pixel_scale/2.0. If buffer_around_corners=False, the grid (y,x) coordinates are defined within the bounding box such that the mask’s edge pixels align with the bouning box.

Parameters:
  • shape_native – The 2D shape of the uniform grid and the mask that it is paired with.
  • 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-grid.
  • origin – The origin of the grid’s mask.
  • buffer_around_corners (bool) – Whether the grid is buffered such that the (y,x) values in the centre of its masks’ edge pixels align with the input bounding box values.
classmethod from_mask(mask: autoarray.mask.mask_2d.Mask2D) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) from a mask, where only unmasked pixels are included in the grid (if the grid is represented in its native 2D masked values are (0.0, 0.0)).

The mask’s pixel_scales, sub_size and origin properties are used to compute the grid (y,x) coordinates.

Parameters:mask (Mask2D) – The mask whose masked pixels are used to setup the sub-pixel grid.
classmethod from_fits(file_path: str, pixel_scales: Union[Tuple[float, float], float], sub_size: int = 1, origin: Tuple[float, float] = (0.0, 0.0)) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Create a Grid2D (see Grid2D.__new__) from a mask, where only unmasked pixels are included in the grid (if the grid is represented in its native 2D masked values are (0.0, 0.0)).

The mask’s pixel_scales, sub_size and origin properties are used to compute the grid (y,x) coordinates.

Parameters:mask (Mask2D) – The mask whose masked pixels are used to setup the sub-pixel grid.
classmethod blurring_grid_from(mask: autoarray.mask.mask_2d.Mask2D, kernel_shape_native: Tuple[int, int]) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Setup a blurring-grid from a mask, where a blurring grid consists of all pixels that are masked (and therefore have their values set to (0.0, 0.0)), but are close enough to the unmasked pixels that their values will be convolved into the unmasked those pixels. This when computing images from light profile objects.

The mask’s pixel_scales, sub_size and origin properties are used to compute the blurring grid’s (y,x) coordinates.

For example, if our mask is as follows:

x x x x x x x x x xI x x x x x x x x x xI This is an imaging.Mask2D, where x x x x x x x x x xI x x x x x x x x x xI x = True (Pixel is masked and excluded from lens) x x xIoIoIo x x x xI o = False (Pixel is not masked and included in lens) x x xIoIoIo x x x xI x x xIoIoIo x x x xI x x x x x x x x x xI x x x x x x x x x xI x x x x x x x x x xI

For a PSF of shape (3,3), the following blurring mask is computed (noting that only pixels that are direct neighbors of the unmasked pixels above will blur light into an unmasked pixel)

x x x x x x x x xI This is an example grid.Mask2D, where x x x x x x x x xI x xIoIoIoIoIo x xI x = True (Pixel is masked and excluded from lens) x xIo x x xIo x xI o = False (Pixel is not masked and included in lens) x xIo x x xIo x xI x xIo x x xIo x xI x xIoIoIoIoIo x xI x x x x x x x x xI x x x x x x x x xI

Thus, the blurring grid coordinates and indexes will be as follows

pixel_scales = 1.0”

positive negative
y x y x

x x x x x x x x xI I blurring_grid[0] = [2.0, -2.0] blurring_grid[9] = [-1.0, -2.0] x x x x x x x x xI I blurring_grid[1] = [2.0, -1.0] blurring_grid[10] = [-1.0, 2.0] x xI0 I1 I2 I3 I4 x xI pos blurring_grid[2] = [2.0, 0.0] blurring_grid[11] = [-2.0, -2.0] x xI5 x x x I6 x xI y blurring_grid[3] = [2.0, 1.0] blurring_grid[12] = [-2.0, -1.0] x xI7 x x x I8 x xI I blurring_grid[4] = [2.0, 2.0] blurring_grid[13] = [-2.0, 0.0] x xI9 x x x I10 x xI neg blurring_grid[5] = [1.0, -2.0] blurring_grid[14] = [-2.0, 1.0] x xI11I12I13I14I15 x xI I blurring_grid[6] = [1.0, 2.0] blurring_grid[15] = [-2.0, 2.0] x x x x x x x x xI I blurring_grid[7] = [0.0, -2.0] x x x x x x x x xI I blurring_grid[8] = [0.0, 2.0]

For a PSF of shape (5,5), the following blurring mask is computed (noting that pixels are 2 pixels from a direct unmasked pixels now blur light into an unmasked pixel)

x x x x x x x x xI This is an example grid.Mask2D, where xIoIoIoIoIoIoIo xI xIoIoIoIoIoIoIo xI x = True (Pixel is masked and excluded from lens) xIoIo x x xIoIo xI o = False (Pixel is not masked and included in lens) xIoIo x x xIoIo xI xIoIo x x xIoIo xI xIoIoIoIoIoIoIo xI xIoIoIoIoIoIoIo xI x x x x x x x x xI
Parameters:
  • mask (Mask2D) – The mask whose masked pixels are used to setup the blurring grid.
  • kernel_shape_native – The 2D shape of the kernel which convolves signal from masked pixels to unmasked pixels.
grid_via_deflection_grid_from(deflection_grid: autoarray.structures.grids.two_d.grid_2d.Grid2D) → autoarray.structures.grids.two_d.grid_2d.Grid2D
Returns a new Grid2D from this grid, where the (y,x) coordinates of this grid have a grid of (y,x) values,
termed the deflection grid, subtracted from them to determine the new grid of (y,x) values.

This is used by PyAutoLens to perform grid ray-tracing.

Parameters:
deflection_grid

The grid of (y,x) coordinates which is subtracted from this grid.

blurring_grid_via_kernel_shape_from(kernel_shape_native: Tuple[int, int]) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Returns the blurring grid from a grid, via an input 2D kernel shape.

For a full description of blurring grids, checkout blurring_grid_from.
Parameters:
kernel_shape_native

The 2D shape of the kernel which convolves signal from masked pixels to unmasked pixels.

grid_with_coordinates_within_distance_removed(coordinates: Union[numpy.ndarray, List[T]], distance: float) → autoarray.structures.grids.two_d.grid_2d.Grid2D

Remove all coordinates from this Grid2D which are within a certain distance of an input list of coordinates.

For example, if the grid has the coordinate (0.0, 0.0) and coordinates=[(0.0, 0.0)], distance=0.1 is input into this function, a new Grid2D will be created which removes the coordinate (0.0, 0.0).

Parameters:
  • coordinates ([(float, float)]) – The list of coordinates which are removed from the grid if they are within the distance threshold.
  • distance – The distance threshold that coordinates are removed if they are within that of the input coordinates.
structure_2d_from(result: numpy.ndarray) → Union[autoarray.structures.arrays.two_d.array_2d.Array2D, autoarray.structures.grids.two_d.grid_2d.Grid2D]

Convert a result from an ndarray to an aa.Array2D or aa.Grid2D structure, where the conversion depends on type(result) as follows:

  • 1D np.ndarray -> aa.Array2D
  • 2D np.ndarray -> aa.Grid2D

This function is used by the grid_2d_to_structure decorator to convert the output result of a function to an autoarray structure when a Grid2D instance is passed to the decorated function.

Parameters:or [np.ndarray] (result) – The input result (e.g. of a decorated function) that is converted to a PyAutoArray structure.
structure_2d_list_from(result_list: List[T]) → List[Union[autoarray.structures.arrays.two_d.array_2d.Array2D, autoarray.structures.grids.two_d.grid_2d.Grid2D]]

Convert a result from a list of ndarrays to a list of aa.Array2D or aa.Grid2D structure, where the conversion depends on type(result) as follows:

  • [1D np.ndarray] -> [aa.Array2D]
  • [2D np.ndarray] -> [aa.Grid2D]

This function is used by the grid_like_list_to_structure-list decorator to convert the output result of a function to a list of autoarray structure when a Grid2D instance is passed to the decorated function.

Parameters:or [np.ndarray] (result_list) – The input result (e.g. of a decorated function) that is converted to a PyAutoArray structure.