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 from_mask(cls, mask, pixel_scales_interp):
"""
Create a Grid2DInterpolate (see `Grid2DInterpolate.__new__`) from a mask, where only unmasked pixels are included in
the grid (if the grid is represented in 2D masked values are (0.0, 0.0)).
The mask's pixel_scales 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.
pixel_scales_interp : float
The resolution of the sparse grid used to evaluate the function, from which the results are interpolated
to the full resolution grid.
"""
pixel_scales_interp = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales_interp)
grid_slim = grid_2d_util.grid_2d_slim_via_mask_from(
mask_2d=mask,
pixel_scales=mask.pixel_scales,
sub_size=mask.sub_size,
origin=mask.origin,
)
return Grid2DInterpolate(grid=grid_slim,
mask=mask,
pixel_scales_interp=pixel_scales_interp)
def uniform(
cls,
shape_native,
pixel_scales,
pixel_scales_interp,
sub_size=1,
origin=(0.0, 0.0),
):
"""
Create a Grid2DInterpolate (see `Grid2DInterpolate.__new__`) as a uniform grid of (y,x) values given an input
shape_native and pixel scale of the grid:
Parameters
----------
shape_native : (float, float)
The 2D shape of the uniform grid and the mask that it 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
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.
"""
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)
grid_slim = grid_2d_util.grid_2d_slim_via_shape_native_from(
shape_native=shape_native,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
return Grid2DInterpolate.manual_slim(
grid=grid_slim,
shape_native=shape_native,
pixel_scales=pixel_scales,
pixel_scales_interp=pixel_scales_interp,
sub_size=sub_size,
origin=origin,
)
def __new__(cls, grid, shape_native=None, pixel_scales=None):
"""
A collection of (y,x) coordinates which is structured as follows:
[[x0, x1], [x0, x1]]
The grid object does not store the coordinates as a list of tuples, but instead a 2D NumPy array of
shape [total_coordinates, 2]. They are stored as a NumPy array so the coordinates can be used efficiently for
calculations.
The coordinates input to this function can have any of the following forms:
[(y0,x0), (y1,x1)]
In all cases, they will be converted to a list of tuples followed by a 2D NumPy array.
Print methods are overidden so a user always "sees" the coordinates as the list structure.
Like the `Grid2D` structure, `Grid2DIrregularUniform` lie on a uniform grid corresponding to values that
originate from a uniform grid. This contrasts the `Grid2DIrregular` class above. However, although this class
stores the pixel-scale and 2D shape of this grid, it does not store the mask that a `Grid2D` does that enables
the coordinates to be mapped from 1D to 2D. This is for calculations that utilize the 2d information of the
grid but do not want the memory overheads associated with the 2D mask.
Parameters
----------
grid : [tuple] or equivalent
A collection of (y,x) coordinates that.
"""
# obj = super(Grid2DIrregularUniform, cls).__new__(cls=cls, coordinates=coordinates)
if len(grid) == 0:
return []
if isinstance(grid[0], float):
grid = [grid]
if isinstance(grid[0], tuple):
grid = [grid]
elif isinstance(grid[0], np.ndarray):
if len(grid[0].shape) == 1:
grid = [grid]
elif isinstance(grid[0], list) and isinstance(grid[0][0], (float)):
grid = [grid]
coordinates_arr = np.concatenate([np.array(i) for i in grid])
obj = coordinates_arr.view(cls)
obj._internal_list = grid
pixel_scales = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales)
obj.shape_native = shape_native
obj.pixel_scales = pixel_scales
return obj
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_yx_and_values(
cls, y, x, values, shape_native, pixel_scales, sub_size=1, exposure_info=None
):
"""Create an `Array2D` (see `AbstractArray2D.__new__`) by inputting the y and x pixel values where the array is filled
and the values to fill the array, for example:
y = np.array([0, 0, 0, 1])
x = np.array([0, 1, 2, 0])
value = [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
----------
y : np.ndarray or list
The y pixel indexes where value sare input, as an ndarray of shape [total_y_pixels*sub_size] or a list.
x : np.ndarray or list
The x pixel indexes where value sare input, as an ndarray of shape [total_y_pixels*sub_size] or a list.
values : np.ndarray or list
The values which are used too fill in the array.
shape_native : (int, int)
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.
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.
"""
pixel_scales = geometry_util.convert_pixel_scales_2d(pixel_scales=pixel_scales)
grid = grid_2d.Grid2D.manual_yx_1d(
y=y, x=x, shape_native=shape_native, pixel_scales=pixel_scales, sub_size=1
)
grid_pixels = grid_2d_util.grid_pixel_indexes_2d_slim_from(
grid_scaled_2d_slim=grid.slim,
shape_native=shape_native,
pixel_scales=pixel_scales,
)
array_1d = np.zeros(shape=shape_native[0] * shape_native[1])
for i in range(grid_pixels.shape[0]):
array_1d[i] = values[int(grid_pixels[i])]
return cls.manual_slim(
array=array_1d,
pixel_scales=pixel_scales,
shape_native=shape_native,
sub_size=sub_size,
exposure_info=exposure_info,
)
def manual_slim(
cls,
array,
shape_native,
pixel_scales,
sub_size=1,
origin=(0.0, 0.0),
exposure_info=None,
):
"""
Create an Array2D (see `AbstractArray2D.__new__`) by inputting the array values in 1D, for example:
array=np.array([1.0, 2.0, 3.0, 4.0])
array=[1.0, 2.0, 3.0, 4.0]
From 1D input the method cannot determine the 2D shape of the array 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
----------
array : np.ndarray or list
The values of the array input as an ndarray of shape [total_unmasked_pixels*(sub_size**2)] or a list of
lists.
shape_native : (int, int)
The 2D shape of the mask the array 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.
sub_size : int
The size (sub_size x sub_size) of each unmasked pixels sub-array.
origin : (float, float)
The (y,x) scaled units origin of the mask's coordinate system.
"""
pixel_scales = geometry_util.convert_pixel_scales_2d(pixel_scales=pixel_scales)
if shape_native is not None and len(shape_native) != 2:
raise exc.ArrayException(
"The input shape_native parameter is not a tuple of type (float, float)"
)
mask = msk.Mask2D.unmasked(
shape_native=shape_native,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
return cls(array=array, mask=mask, exposure_info=exposure_info)
def manual(
cls,
mask: np.ndarray or list,
pixel_scales: (float, float),
sub_size: int = 1,
origin: (float, float) = (0.0, 0.0),
invert: bool = False,
) -> "Mask2D":
"""
Returns a Mask2D (see `AbstractMask2D.__new__`) by inputting the array values in 2D, for example:
mask=np.array([[False, False],
[True, False]])
mask=[[False, False],
[True, False]]
Parameters
----------
mask : np.ndarray or list
The `bool` values of the mask input as an `np.ndarray` of shape [total_y_pixels, total_x_pixels] 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-array.
origin : (float, float)
The (y,x) scaled units origin of the mask's coordinate system.
invert : bool
If `True`, the `bool`'s of the input `mask` are inverted, for example `False`'s become `True`
and visa versa.
"""
if type(mask) is list:
mask = np.asarray(mask).astype("bool")
if invert:
mask = np.invert(mask)
pixel_scales = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales)
if len(mask.shape) != 2:
raise exc.MaskException(
"The input mask is not a two dimensional array")
return cls(mask=mask,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin)
def uniform(
cls,
shape_native,
pixel_scales,
origin=(0.0, 0.0),
fractional_accuracy=0.9999,
sub_steps=None,
):
"""
Create a Grid2DIterate (see *Grid2DIterate.__new__*) as a uniform grid of (y,x) values given an input
shape_native and pixel scale of the grid:
Parameters
----------
shape_native : (float, float)
The 2D shape of the uniform grid and the mask that it 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.
"""
pixel_scales = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales)
grid_slim = grid_2d_util.grid_2d_slim_via_shape_native_from(
shape_native=shape_native,
pixel_scales=pixel_scales,
sub_size=1,
origin=origin,
)
return Grid2DIterate.manual_slim(
grid=grid_slim,
shape_native=shape_native,
pixel_scales=pixel_scales,
fractional_accuracy=fractional_accuracy,
sub_steps=sub_steps,
origin=origin,
)
def manual_native(
cls, array, pixel_scales, sub_size=1, origin=(0.0, 0.0), exposure_info=None
):
"""Create an Array2D (see `AbstractArray2D.__new__`) by inputting the array values in 2D, for example:
array=np.ndarray([[1.0, 2.0],
[3.0, 4.0]])
array=[[1.0, 2.0],
[3.0, 4.0]]
The 2D shape of the array and its mask are determined from the input array and the mask is setup as an
unmasked `Mask2D` of shape_native.
Parameters
----------
array : np.ndarray or list
The values of the array input as an ndarray of shape [total_y_pixels*sub_size, total_x_pixel*sub_size] 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-array.
origin : (float, float)
The (y,x) scaled units origin of the mask's coordinate system.
"""
pixel_scales = geometry_util.convert_pixel_scales_2d(pixel_scales=pixel_scales)
array = abstract_array.convert_array(array=array)
shape_native = (int(array.shape[0] / sub_size), int(array.shape[1] / sub_size))
mask = msk.Mask2D.unmasked(
shape_native=shape_native,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
array = abstract_array_2d.convert_array_2d(array_2d=array, mask_2d=mask)
return cls(array=array, mask=mask, exposure_info=exposure_info)
def manual_slim(cls,
grid,
shape_native,
pixel_scales,
sub_size=1,
origin=(0.0, 0.0)):
"""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
----------
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.
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.
"""
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=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_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 uniform(
cls,
shape_native: Tuple[float, float],
pixel_scales: Union[float, Tuple[float, float]],
sub_size: int = 1,
origin: Tuple[float, float] = (0.0, 0.0),
) -> "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.
"""
pixel_scales = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales)
grid_slim = grid_2d_util.grid_2d_slim_via_shape_native_from(
shape_native=shape_native,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
return cls.manual_slim(
grid=grid_slim,
shape_native=shape_native,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin,
)
def from_grid_sparse_uniform_upscale(cls,
grid_sparse_uniform,
upscale_factor,
pixel_scales,
shape_native=None):
pixel_scales = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales)
grid_upscaled_1d = grid_2d_util.grid_2d_slim_upscaled_from(
grid_slim=grid_sparse_uniform,
upscale_factor=upscale_factor,
pixel_scales=pixel_scales,
)
pixel_scales = (
pixel_scales[0] / upscale_factor,
pixel_scales[1] / upscale_factor,
)
return cls(grid=grid_upscaled_1d,
pixel_scales=pixel_scales,
shape_native=shape_native)
def manual(cls, mask, pixel_scales, origin=(0.0, 0.0), invert=False):
"""Create a Mask2D (see *Mask2D.__new__*) by inputting the array values in 2D, for example:
mask=np.array([[False, False],
[True, False]])
mask=[[False, False],
[True, False]]
Parameters
----------
mask : np.ndarray or list
The bool values of the mask input as an ndarray of shape [total_y_pixels, total_x_pixels ]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.
origin : (float, float)
The (y,x) scaled units origin of the mask's coordinate system.
invert : bool
If `True`, the ``bool``'s of the input ``mask`` are inverted, for example `False`'s become `True`
and visa versa.
"""
if type(mask) is list:
mask = np.asarray(mask).astype("bool")
if invert:
mask = np.invert(mask)
pixel_scales = geometry_util.convert_pixel_scales_2d(
pixel_scales=pixel_scales)
if len(mask.shape) != 2:
raise exc.MaskException(
"The input mask is not a two dimensional array")
return cls(mask=mask, pixel_scales=pixel_scales, origin=origin)