def convert_grid_2d(grid_2d, mask_2d):
"""
Manual Grid2D functions take as input a list or ndarray which is to be returned as an Grid2D. This function
performs the following and checks and conversions on the input:
1) If the input is a list, convert it to an ndarray.
2) Check that the number of sub-pixels in the array is identical to that of the mask.
3) Map the input ndarray to its `slim` representation.
For a Grid2D, `slim` refers to a 2D NumPy array of shape [total_coordinates, 2] and `native` a 3D NumPy array of
shape [total_y_coordinates, total_x_coordinates, 2]
Parameters
----------
array : np.ndarray or list
The input structure which is converted to an ndarray if it is a list.
mask_2d : Mask2D
The mask of the output Array2D.
"""
grid_2d = abstract_grid.convert_grid(grid=grid_2d)
if len(grid_2d.shape) == 2:
return abstract_grid.convert_grid(grid=grid_2d)
return grid_2d_util.grid_2d_slim_from(grid_2d_native=grid_2d,
mask=mask_2d,
sub_size=mask_2d.sub_size)
def manual_mask(cls, grid, mask):
"""
Create a Grid1D (see `Grid1D.__new__`) by inputting the grid coordinates in 1D with their corresponding mask.
See the manual_slim and manual_native methods for examples.
Parameters
----------
grid : np.ndarray or list
The (x) coordinates of the grid input as an ndarray of shape [total_coordinates*sub_size] or a list of lists.
mask : msk.Mask1D
The 1D mask associated with the grid, defining the pixels each grid coordinate is paired with and
originates from.
"""
grid = abstract_grid.convert_grid(grid=grid)
if grid.shape[0] == mask.sub_shape_native[0]:
grid = grid_1d_util.grid_1d_slim_from(grid_1d_native=grid,
mask_1d=mask,
sub_size=mask.sub_size)
elif grid.shape[0] != mask.shape[0]:
raise exc.GridException(
"The grid input into manual_mask does not have matching dimensions with the mask"
)
return Grid1D(grid=grid, mask=mask)
def manual_slim(cls, grid, pixel_scales, sub_size=1, origin=(0.0, )):
"""
Create a Grid1D (see *Grid1D.__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]]
Parameters
----------
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.
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.
"""
pixel_scales = geometry_util.convert_pixel_scales_1d(
pixel_scales=pixel_scales)
grid = abstract_grid.convert_grid(grid=grid)
mask = mask_1d.Mask1D.unmasked(
shape_slim=grid.shape[0] // sub_size,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
return Grid1D(grid=grid, mask=mask)
def manual_slim(
cls,
grid,
shape_native,
pixel_scales,
origin=(0.0, 0.0),
fractional_accuracy=0.9999,
sub_steps=None,
):
"""
Create a Grid2DIterate (see *Grid2DIterate.__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
----------
grid : np.ndarray or list
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 : (float, float)
The 2D shape of the mask the grid is paired with.
pixel_scales: (float, float) or float
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.
fractional_accuracy : float
The fractional accuracy the function evaluated must meet to be accepted, where this accuracy is the ratio
of the value at a higher sub_size to othe value computed using the previous sub_size.
sub_steps : [int] or None
The sub-size values used to iteratively evaluated the function at high levels of sub-gridding. If None,
they are setup as the default values [2, 4, 8, 16].
origin : (float, float)
The origin of the grid's mask.
"""
grid = abstract_grid.convert_grid(grid=grid)
pixel_scales = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales)
mask = msk.Mask2D.unmasked(
shape_native=shape_native,
pixel_scales=pixel_scales,
sub_size=1,
origin=origin,
)
return Grid2DIterate(
grid=grid,
mask=mask,
fractional_accuracy=fractional_accuracy,
sub_steps=sub_steps,
)
def manual_slim(
cls,
grid,
shape_native,
pixel_scales,
pixel_scales_interp,
sub_size=1,
origin=(0.0, 0.0),
):
"""
Create a Grid2DInterpolate (see `Grid2DInterpolate.__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
----------
grid : np.ndarray or list
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 : (float, float)
The 2D shape of the mask the grid is paired with.
pixel_scales: (float, float) or float
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.
pixel_scales_interp : (float, float) or float
The resolution of the sparse grid used to evaluate the function, from which the results are interpolated
to the full resolution grid.
origin : (float, float)
The origin of the grid's mask.
"""
grid = abstract_grid.convert_grid(grid=grid)
pixel_scales = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales)
pixel_scales_interp = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales_interp)
mask = msk.Mask2D.unmasked(
shape_native=shape_native,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
return Grid2DInterpolate(grid=grid,
mask=mask,
pixel_scales_interp=pixel_scales_interp)
def manual_native(cls, grid, pixel_scales, sub_size=1, origin=(0.0, 0.0)):
"""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
----------
grid : np.ndarray or list
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: (float, float) or float
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 : int
The size (sub_size x sub_size) of each unmasked pixels sub-grid.
origin : (float, float)
The origin of the grid's mask.
"""
grid = abstract_grid.convert_grid(grid=grid)
pixel_scales = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales)
shape = (int(grid.shape[0] / sub_size), int(grid.shape[1] / sub_size))
mask = msk.Mask2D.unmasked(
shape_native=shape,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
grid = abstract_grid_2d.convert_grid_2d(grid_2d=grid, mask_2d=mask)
return Grid2D(grid=grid, mask=mask)
def manual_mask(cls, grid, 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.
See the manual_slim and manual_native methods for examples.
Parameters
----------
grid : np.ndarray or list
The (y,x) coordinates of the grid input as an ndarray of shape [total_sub_coordinates, 2] or list of lists.
mask : msk.Mask2D
The 2D mask associated with the grid, defining the pixels each grid coordinate is paired with and
originates from.
"""
grid = abstract_grid.convert_grid(grid=grid)
abstract_grid_2d.check_grid_2d_and_mask_2d(grid_2d=grid, mask_2d=mask)
grid = abstract_grid_2d.convert_grid_2d(grid_2d=grid, mask_2d=mask)
return Grid2D(grid=grid, mask=mask)
