def mask_blurring_from_mask_and_psf_shape(mask, psf_shape): """Compute a blurring masks from an input masks and psf shape. The blurring masks corresponds to all pixels which are outside of the masks but will have a fraction of their \ light blur into the masked region due to PSF convolution.""" blurring_mask = np.full(mask.shape, True) for y in range(mask.shape[0]): for x in range(mask.shape[1]): if not mask[y, x]: for y1 in range((-psf_shape[0] + 1) // 2, (psf_shape[0] + 1) // 2): for x1 in range((-psf_shape[1] + 1) // 2, (psf_shape[1] + 1) // 2): if 0 <= x + x1 <= mask.shape[ 1] - 1 and 0 <= y + y1 <= mask.shape[0] - 1: if mask[y + y1, x + x1]: blurring_mask[y + y1, x + x1] = False else: raise exc.MaskException( "setup_blurring_mask extends beyond the sub_grid_size of the masks - pad the " "datas array before masking") return blurring_mask
def blurring_mask_from_mask_and_psf_shape(mask, psf_shape): """Compute 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 dimensionos of the input mask, an error is raised and the user \ should pad the input mask (and associated images). Parameters ----------- mask : ndarray A 2D array of bools, where *False* values are unmasked. psf_shape : (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, psf_shape=(3,3)) """ blurring_mask = np.full(mask.shape, True) for y in range(mask.shape[0]): for x in range(mask.shape[1]): if not mask[y, x]: for y1 in range((-psf_shape[0] + 1) // 2, (psf_shape[0] + 1) // 2): for x1 in range((-psf_shape[1] + 1) // 2, (psf_shape[1] + 1) // 2): if (0 <= x + x1 <= mask.shape[1] - 1 and 0 <= y + y1 <= mask.shape[0] - 1): if mask[y + y1, x + x1]: blurring_mask[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
def blurring_mask_for_psf_shape(self, psf_shape): """Compute a blurring mask, which represents all masked pixels whose light will be blurred into unmasked \ pixels via PSF convolution (see grid_stack.RegularGrid.blurring_grid_from_mask_and_psf_shape). Parameters ---------- psf_shape : (int, int) The shape of the psf which defines the blurring region (e.g. the shape of the PSF) """ if psf_shape[0] % 2 == 0 or psf_shape[1] % 2 == 0: raise exc.MaskException("psf_size of exterior region must be odd") blurring_mask = mask_util.mask_blurring_from_mask_and_psf_shape( self, psf_shape) return Mask(blurring_mask, self.pixel_scale)