autoarray.inversion.pixelizations.DelaunayBrightnessImage#

class autoarray.inversion.pixelizations.DelaunayBrightnessImage(pixels=10, weight_floor=0.0, weight_power=0.0)[source]#
__init__(pixels=10, weight_floor=0.0, weight_power=0.0)[source]#

A pixelization associates a 2D grid of (y,x) coordinates (which are expected to be aligned with a masked dataset) with a 2D grid of pixels. The Delaunay pixelization represents pixels as an irregular 2D grid of Delaunay triangles.

Both of these grids (e.g. the masked dataset’s 2D grid and the grid of the Delaunay pixelization’s pixels) have (y,x) coordinates in two reference frames:

  • data: the original reference frame of the masked data.

  • source: a reference frame where grids in the data reference frame are transformed to a new reference

frame (e.g. their (y,x) coordinates may be shifted, stretched or have a more complicated operation performed on them).

The grid associated with the masked dataset and Delaunay pixelization have the following variable names:

  • grid_slim: the (y,x) grid of coordinates of the original masked data (which can be in the data frame and

given the variable name data_grid_slim or in the transformed source frame with the variable name source_grid_slim).

  • pixelization_grid: the (y,x) grid of Delaunay pixels which are associated with the grid_slim (y,x)

coordinates (association is always performed in the source reference frame).

A Delaunay pixelization has four grids associated with it: data_grid_slim, source_grid_slim, data_pixelization_grid and source_pixelization_grid.

If a transformation of coordinates is not applied, the data frame and source frames are identical.

Each (y,x) coordinate in the source_grid_slim is associated with the three nearest Delaunay triangle corners (when joined together with straight lines these corners form Delaunay triangles). This association uses weighted interpolation whereby source_grid_slim coordinates are associated to the Delaunay corners with a higher weight if they are a closer distance to one another.

For the DelaunayBrightnessImage pixelization the corners of the Delaunay trinagles are derived in the data frame, by applying a KMeans clustering algorithm to the masked data’s values. These values are use compute pixels number of pixels, where the weight_floor and weight_power allow the KMeans algorithm to adapt the derived pixel centre locations to the data’s brighest or faintest values.

In the project PyAutoLens, one’s data is a masked 2D image. Its data_grid_slim is a 2D grid where every (y,x) coordinate is aligned with the centre of every unmasked image pixel. A “lensing operation” transforms this grid of (y,x) coordinates from the data frame to a new grid of (y,x) coordinates in the source frame. The pixelization is then applied in the source frame.. In lensing terminology, the data frame is the image-plane and source frame the source-plane.

Parameters
  • pixels – The total number of pixels in the Delaunay pixelization, which is therefore also the number of (y,x) coordinates computed via the KMeans clustering algorithm in data frame.

  • weight_floor – A parameter which reweights the data values the KMeans algorithm is applied too; as the floor increases more weight is applied to values with lower values thus allowing Delaunay pixels to be placed in these regions of the data.

  • weight_power – A parameter which reweights the data values the KMeans algorithm is applied too; as the power increases more weight is applied to values with higher values thus allowing Delaunay pixels to be placed in these regions of the data.

Methods

__init__([pixels, weight_floor, weight_power])

A pixelization associates a 2D grid of (y,x) coordinates (which are expected to be aligned with a masked dataset) with a 2D grid of pixels.

data_pixelization_grid_from(data_grid_slim, …)

Computes the pixelization_grid in the data frame, by overlaying a uniform grid of coordinates over the masked 2D data (see Grid2DSparse.from_grid_and_unmasked_2d_grid_shape()).

make_pixelization_grid([source_grid_slim, …])

Return the Delaunay source_pixelization_grid as a Grid2DDelaunay object, which provides additional functionality for performing operations that exploit the geometry of a Delaunay pixelization.

mapper_from(source_grid_slim[, …])

Mapper objects describe the mappings between pixels in the masked 2D data and the pixels in a pixelization, in both the data and source frames.

pixelization_grid_from(source_grid_slim, …)

relocate_pixelization_grid_via_border(…[, …])

Relocates all coordinates of the input source_pixelization_grid that are outside of a border (which is defined by a grid of (y,x) coordinates) to the edge of this border.

relocated_grid_from(source_grid_slim[, …])

Relocates all coordinates of the input source_grid_slim that are outside of a border (which is defined by a grid of (y,x) coordinates) to the edge of this border.

relocated_pixelization_grid_from(…[, settings])

weight_map_from(hyper_image)

Computes a weight_map from an input hyper_image, where this image represents components in the masked 2d data in the data frame.

Attributes

is_stochastic

uses_interpolation