def test_split_kernel():
kernel = np.zeros((9, 9))
kernel[4, 4] = 1
subgrid_res = 3
subgrid_kernel = kernel_util.subgrid_kernel(kernel,
subgrid_res=subgrid_res,
odd=True)
subsampling_size = 3
kernel_hole, kernel_cutout = kernel_util.split_kernel(
subgrid_kernel,
supersampling_kernel_size=subsampling_size,
supersampling_factor=subgrid_res)
assert kernel_hole[4, 4] == 0
assert len(kernel_cutout) == subgrid_res * subsampling_size
npt.assert_almost_equal(np.sum(kernel_hole) + np.sum(kernel_cutout),
1,
decimal=4)
subgrid_res = 2
subgrid_kernel = kernel_util.subgrid_kernel(kernel,
subgrid_res=subgrid_res,
odd=True)
subsampling_size = 3
kernel_hole, kernel_cutout = kernel_util.split_kernel(
subgrid_kernel,
supersampling_kernel_size=subsampling_size,
supersampling_factor=subgrid_res)
assert kernel_hole[4, 4] == 0
assert len(kernel_cutout) == subgrid_res * subsampling_size + 1
npt.assert_almost_equal(np.sum(kernel_hole) + np.sum(kernel_cutout),
1,
decimal=4)
def __init__(self,
kernel_supersampled,
supersampling_factor,
supersampling_size=None,
convolution_type='fft'):
"""
:param kernel_supersampled: kernel in supersampled pixels
:param supersampling_factor: supersampling factor relative to the image pixel grid
:param supersampling_size: number of pixels (in units of the image pixels) that are convolved with the
supersampled kernel
"""
n_high = len(kernel_supersampled)
self._supersampling_factor = supersampling_factor
numPix = int(n_high / self._supersampling_factor)
if self._supersampling_factor % 2 == 0:
self._kernel = kernel_util.averaging_even_kernel(
kernel_supersampled, self._supersampling_factor)
else:
self._kernel = util.averaging(kernel_supersampled,
numGrid=n_high,
numPix=numPix)
if supersampling_size is None:
kernel_low_res, kernel_high_res = np.zeros_like(
self._kernel), kernel_supersampled
self._low_res_convolution = False
else:
kernel_low_res, kernel_high_res = kernel_util.split_kernel(
self._kernel, kernel_supersampled, supersampling_size,
self._supersampling_factor)
self._low_res_convolution = True
self._low_res_conv = PixelKernelConvolution(
kernel_low_res, convolution_type=convolution_type)
self._high_res_conv = PixelKernelConvolution(
kernel_high_res, convolution_type=convolution_type)
def potential_from_kappa_grid_adaptive(kappa_high_res, grid_spacing,
low_res_factor, high_res_kernel_size):
"""
lensing potential on the convergence grid
the computation is performed as a convolution of the Green's function with the convergence map using FFT
:param kappa_high_res: 2d grid of convergence values
:param grid_spacing: scale of an individual pixel (per axis) of grid
:param low_res_factor: lower resolution factor of larger scale kernel.
:param high_res_kernel_size: int, size of high resolution kernel in units of degraded pixels
:return: lensing potential in a 2d grid at positions x_grid, y_grid
"""
kappa_low_res = image_util.re_size(kappa_high_res, factor=low_res_factor)
num_pix = len(kappa_high_res) * 2
if num_pix % 2 == 0:
num_pix += 1
grid_spacing_low_res = grid_spacing * low_res_factor
kernel = potential_kernel(num_pix, grid_spacing)
kernel_low_res, kernel_high_res = kernel_util.split_kernel(
kernel, high_res_kernel_size, low_res_factor, normalized=False)
f_high_res = scp.fftconvolve(kappa_high_res, kernel_high_res,
mode='same') / np.pi * grid_spacing**2
f_high_res = image_util.re_size(f_high_res, low_res_factor)
f_low_res = scp.fftconvolve(kappa_low_res, kernel_low_res,
mode='same') / np.pi * grid_spacing_low_res**2
return f_high_res + f_low_res
def test_raise(self):
with self.assertRaises(ValueError):
kernel = np.zeros((2, 2))
kernel_util.center_kernel(kernel, iterations=1)
with self.assertRaises(ValueError):
kernel_super = np.ones((9, 9))
kernel_util.split_kernel(kernel_super, supersampling_kernel_size=2, supersampling_factor=3)
with self.assertRaises(ValueError):
kernel_util.split_kernel(kernel_super, supersampling_kernel_size=3, supersampling_factor=0)
with self.assertRaises(ValueError):
image = np.ones((10, 10))
kernel_util.cutout_source(x_pos=3, y_pos=2, image=image, kernelsize=2)
with self.assertRaises(ValueError):
kernel_util.fwhm_kernel(kernel=np.ones((4, 4)))
with self.assertRaises(ValueError):
kernel_util.fwhm_kernel(kernel=np.ones((5, 5)))
def deflection_from_kappa_grid_adaptive(kappa_high_res, grid_spacing,
low_res_factor, high_res_kernel_size):
"""
deflection angles on the convergence grid with adaptive FFT
the computation is performed as a convolution of the Green's function with the convergence map using FFT
The grid is returned in the lower resolution grid
:param kappa_high_res: convergence values for each pixel (2-d array)
:param grid_spacing: pixel size of high resolution grid
:param low_res_factor: lower resolution factor of larger scale kernel.
:param high_res_kernel_size: int, size of high resolution kernel in units of degraded pixels
:return: numerical deflection angles in x- and y- direction
"""
kappa_low_res = image_util.re_size(kappa_high_res, factor=low_res_factor)
num_pix = len(kappa_high_res) * 2
if num_pix % 2 == 0:
num_pix += 1
#if high_res_kernel_size % low_res_factor != 0:
# assert ValueError('fine grid kernel size needs to be a multiplicative factor of low_res_factor! Settings used: '
# 'fine_grid_kernel_size=%s, low_res_factor=%s' % (high_res_kernel_size, low_res_factor))
kernel_x, kernel_y = deflection_kernel(num_pix, grid_spacing)
grid_spacing_low_res = grid_spacing * low_res_factor
kernel_low_res_x, kernel_high_res_x = kernel_util.split_kernel(
kernel_x, high_res_kernel_size, low_res_factor, normalized=False)
f_x_high_res = scp.fftconvolve(kappa_high_res,
kernel_high_res_x,
mode='same') / np.pi * grid_spacing**2
f_x_high_res = image_util.re_size(f_x_high_res, low_res_factor)
f_x_low_res = scp.fftconvolve(
kappa_low_res, kernel_low_res_x,
mode='same') / np.pi * grid_spacing_low_res**2
f_x = f_x_high_res + f_x_low_res
kernel_low_res_y, kernel_high_res_y = kernel_util.split_kernel(
kernel_y, high_res_kernel_size, low_res_factor, normalized=False)
f_y_high_res = scp.fftconvolve(kappa_high_res,
kernel_high_res_y,
mode='same') / np.pi * grid_spacing**2
f_y_high_res = image_util.re_size(f_y_high_res, low_res_factor)
f_y_low_res = scp.fftconvolve(
kappa_low_res, kernel_low_res_y,
mode='same') / np.pi * grid_spacing_low_res**2
f_y = f_y_high_res + f_y_low_res
return f_x, f_y
def psf_convolution_new(self,
unconvolved_image,
subgrid_res=1,
subsampling_size=11,
psf_subgrid=True):
"""
:param unconvolved_image: 2d image with subsampled pixels with subgrid_res
:param subgrid_res: subsampling resolution
:param subsampling_size: size of the subsampling convolution in units of image pixels
:param psf_subgrid: bool, if False, the convolution is performed on the pixel size of the data
:return: convolved 2d image in units of the pixels
"""
unconvolved_image_resized = image_util.re_size(unconvolved_image,
subgrid_res)
if self.psf_type == 'NONE':
image_conv_resized = unconvolved_image_resized
elif self.psf_type == 'GAUSSIAN':
if psf_subgrid is True:
grid_scale = self._pixel_size / float(subgrid_res)
sigma = self._sigma_gaussian / grid_scale
image_conv = ndimage.filters.gaussian_filter(
unconvolved_image,
sigma,
mode='nearest',
truncate=self._truncation)
image_conv_resized = image_util.re_size(
image_conv, subgrid_res)
else:
sigma = self._sigma_gaussian / self._pixel_size
image_conv_resized = ndimage.filters.gaussian_filter(
unconvolved_image_resized,
sigma,
mode='nearest',
truncate=self._truncation)
elif self.psf_type == 'PIXEL':
kernel = self._kernel_pixel
if subgrid_res > 1 and psf_subgrid is True:
kernel_subgrid = self.subgrid_pixel_kernel(subgrid_res)
kernel, kernel_subgrid = kernel_util.split_kernel(
kernel, kernel_subgrid, subsampling_size, subgrid_res)
image_conv_subgrid = signal.fftconvolve(unconvolved_image,
kernel_subgrid,
mode='same')
image_conv_resized_1 = image_util.re_size(
image_conv_subgrid, subgrid_res)
image_conv_resized_2 = signal.fftconvolve(
unconvolved_image_resized, kernel, mode='same')
image_conv_resized = image_conv_resized_1 + image_conv_resized_2
else:
image_conv_resized = signal.fftconvolve(
unconvolved_image_resized, kernel, mode='same')
else:
raise ValueError('PSF type %s not valid!' % self.psf_type)
return image_conv_resized