def manual(
cls,
mask: Union[List, np.ndarray],
pixel_scales: Union[float, Tuple[float]],
sub_size: int = 1,
origin: Tuple[float] = (0.0, ),
invert: bool = False,
) -> "Mask1D":
if type(mask) is list:
mask = np.asarray(mask).astype("bool")
if invert:
mask = np.invert(mask)
if type(pixel_scales) is float:
pixel_scales = (pixel_scales, )
if len(mask.shape) != 1:
raise exc.MaskException(
"The input mask is not a one dimensional array")
return Mask1D(mask=mask,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin)
def pixel_scale(self):
if self.pixel_scales[0] == self.pixel_scales[1]:
return self.pixel_scales[0]
else:
raise exc.MaskException(
"Cannot return a pixel_scale for a a grid where each dimension has a "
"different pixel scale (e.g. pixel_scales[0] != pixel_scales[1]"
)
def blurring_mask_2d_from(mask_2d: np.ndarray,
kernel_shape_native: Tuple[int, int]) -> np.ndarray:
"""
Returns a blurring mask from an input mask and psf shape.
The blurring mask corresponds to all pixels which are outside of the mask but will have a fraction of their
light blur into the masked region due to PSF convolution. The PSF shape is used to determine which pixels these are.
If a pixel is identified which is outside the 2D dimensions of the input mask, an error is raised and the user
should pad the input mask (and associated images).
Parameters
-----------
mask_2d : np.ndarray
A 2D array of bools, where `False` values are unmasked.
kernel_shape_native : (int, int)
The 2D shape of the PSF which is used to compute the blurring mask.
Returns
-------
ndarray
The 2D blurring mask array whose unmasked values (`False`) correspond to where the mask will have PSF light
blurred into them.
Examples
--------
mask = np.array([[True, True, True],
[True, False, True]
[True, True, True]])
blurring_mask = blurring_mask_from_mask_and_psf_shape(mask=mask)
"""
blurring_mask_2d = np.full(mask_2d.shape, True)
for y in range(mask_2d.shape[0]):
for x in range(mask_2d.shape[1]):
if not mask_2d[y, x]:
for y1 in range(
(-kernel_shape_native[0] + 1) // 2,
(kernel_shape_native[0] + 1) // 2,
):
for x1 in range(
(-kernel_shape_native[1] + 1) // 2,
(kernel_shape_native[1] + 1) // 2,
):
if (0 <= x + x1 <= mask_2d.shape[1] - 1
and 0 <= y + y1 <= mask_2d.shape[0] - 1):
if mask_2d[y + y1, x + x1]:
blurring_mask_2d[y + y1, x + x1] = False
else:
raise exc.MaskException(
"setup_blurring_mask extends beyond the sub_size "
"of the mask - pad the datas array before masking"
)
return blurring_mask_2d
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 pixel_scale(self):
"""
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``.
"""
for pixel_scale in self.pixel_scales:
if pixel_scale != self.pixel_scales[0]:
raise exc.MaskException(
"Cannot return a pixel_scale for a grid where each dimension has a "
"different pixel scale (e.g. pixel_scales[0] != pixel_scales[1]"
)
return self.pixel_scales[0]
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)
def manual(cls,
mask_2d,
pixel_scales=None,
sub_size=1,
origin=(0.0, 0.0),
invert=False):
if type(mask_2d) is list:
mask_2d = np.asarray(mask_2d).astype("bool")
if invert:
mask_2d = np.invert(mask_2d)
if type(pixel_scales) is float:
pixel_scales = (pixel_scales, pixel_scales)
if len(mask_2d.shape) != 2:
raise exc.MaskException(
"The input mask_2d is not a two dimensional array")
return Mask(mask_2d=mask_2d,
pixel_scales=pixel_scales,
sub_size=sub_size,
origin=origin)
