Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_raise(self):
with self.assertRaises(ValueError):
grid2d = np.zeros((7, 7))
x_pos, y_pos = 4, 1
kernel = np.ones((2, 2))
added = image_util.add_layer2image_int(grid2d, x_pos, y_pos, kernel)
with self.assertRaises(ValueError):
image = np.ones((5, 5))
image_util.re_size(image, factor=2)
with self.assertRaises(ValueError):
image = np.ones((5, 5))
image_util.re_size(image, factor=0.5)
with self.assertRaises(ValueError):
image = np.ones((5, 5))
image_util.cut_edges(image, numPix=7)
with self.assertRaises(ValueError):
image = np.ones((5, 6))
image_util.cut_edges(image, numPix=3)
with self.assertRaises(ValueError):
image = np.ones((5, 5))
image_util.cut_edges(image, numPix=2)
def test_kernel_subsampled(self):
deltaPix = 0.05 # pixel size of image
numPix = 40 # number of pixels per axis
subsampling_res = 3 # subsampling scale factor (in each dimension)
fwhm = 0.3 # FWHM of the PSF kernel
fwhm_object = 0.2 # FWHM of the Gaussian source to be convolved
# create Gaussian/Pixelized kernels
# first we create the sub-sampled kernel
kernel_point_source_subsampled = kernel_util.kernel_gaussian(kernel_numPix=11*subsampling_res, deltaPix=deltaPix/subsampling_res, fwhm=fwhm)
# to have the same consistent kernel, we re-size (average over the sub-sampled pixels) the sub-sampled kernel
kernel_point_source = image_util.re_size(kernel_point_source_subsampled, subsampling_res)
# here we create the two PSF() classes
kwargs_pixel_subsampled = {'psf_type': 'PIXEL', 'kernel_point_source': kernel_point_source_subsampled,
'point_source_supersampling_factor': subsampling_res}
psf_pixel_subsampled = PSF(**kwargs_pixel_subsampled)
psf_pixel_subsampled.kernel_point_source_supersampled(supersampling_factor=subsampling_res+1)
kernel_point_source /= np.sum(kernel_point_source)
kwargs_pixel = {'psf_type': 'PIXEL',
'kernel_point_source': kernel_point_source}
psf_pixel = PSF(**kwargs_pixel)
kernel_point_source = psf_pixel.kernel_point_source
kernel_super = psf_pixel.kernel_point_source_supersampled(supersampling_factor=3)
npt.assert_almost_equal(np.sum(kernel_point_source), np.sum(kernel_super), decimal=8)
npt.assert_almost_equal(np.sum(kernel_point_source), 1, decimal=8)
deltaPix = 0.05 # pixel size of image
def test_subgrid_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)
kernel_re_sized = image_util.re_size(subgrid_kernel, factor=subgrid_res) *subgrid_res**2
#import matplotlib.pyplot as plt
#plt.matshow(kernel); plt.show()
#plt.matshow(subgrid_kernel); plt.show()
#plt.matshow(kernel_re_sized);plt.show()
#plt.matshow(kernel_re_sized- kernel);plt.show()
npt.assert_almost_equal(kernel_re_sized[4, 4], 1, decimal=2)
assert np.max(subgrid_kernel) == subgrid_kernel[13, 13]
#assert kernel_re_sized[4, 4] == 1
:param kwargs_lens_light:
:param kwargs_ps:
:param no_noise:
:param source_add:
:param lens_light_add:
:param point_source_add:
:return:
"""
image = image_model_class.image(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps, source_add=source_add, lens_light_add=lens_light_add, point_source_add=point_source_add)
# add noise
if no_noise:
return image
else:
poisson = image_util.add_poisson(image, exp_time=image_model_class.Data.exposure_map)
bkg = image_util.add_background(image, sigma_bkd=image_model_class.Data.background_rms)
return image + bkg + poisson
def convolve2d(self, image_high_res):
"""
:param image_high_res: supersampled image/model to be convolved on a regular pixel grid
:return: convolved and re-sized image
"""
image_low_res = image_util.re_size(image_high_res, factor=self._supersampling_factor)
return self.re_size_convolve(image_low_res, image_high_res)
:param ra_pos:
:param dec_pos:
:param amp:
:return:
"""
subgrid = self._supersampling_factor
x_pos, y_pos = self._pixel_grid.map_coord2pix(ra_pos, dec_pos)
# translate coordinates to higher resolution grid
x_pos_subgird = x_pos * subgrid + (subgrid - 1) / 2.
y_pos_subgrid = y_pos * subgrid + (subgrid - 1) / 2.
kernel_point_source_subgrid = self._kernel_supersampled
# initialize grid with higher resolution
subgrid2d = np.zeros((self._nx*subgrid, self._ny*subgrid))
# add_layer2image
for i in range(len(x_pos)):
subgrid2d = image_util.add_layer2image(subgrid2d, x_pos_subgird[i], y_pos_subgrid[i], amp[i] * kernel_point_source_subgrid)
# re-size grid to data resolution
grid2d = image_util.re_size(subgrid2d, factor=subgrid)
return grid2d*subgrid**2
y_mins = y_mins[delta_map <= min_distance*mag*5]
if verbose is True:
print("The number of regions that meet the plausibility criteria are %s" % len(x_mins))
x_mins = np.append(x_mins, np.random.uniform(low=-search_window/2+x_center, high=search_window/2+x_center,
size=num_random))
y_mins = np.append(y_mins, np.random.uniform(low=-search_window / 2 + y_center, high=search_window / 2 + y_center,
size=num_random))
# iterative solving of the lens equation for the selected grid points
x_mins, y_mins, solver_precision = self._find_gradient_decent(x_mins, y_mins, sourcePos_x, sourcePos_y, kwargs_lens,
precision_limit, num_iter_max, verbose=verbose,
min_distance=min_distance, non_linear=non_linear)
# only select iterative results that match the precision limit
x_mins = x_mins[solver_precision <= precision_limit]
y_mins = y_mins[solver_precision <= precision_limit]
# find redundant solutions within the min_distance criterion
x_mins, y_mins = image_util.findOverlap(x_mins, y_mins, min_distance)
if arrival_time_sort is True:
x_mins, y_mins = self.sort_arrival_times(x_mins, y_mins, kwargs_lens)
if magnification_limit is not None:
mag = np.abs(self.lensModel.magnification(x_mins, y_mins, kwargs_lens))
x_mins = x_mins[mag >= magnification_limit]
y_mins = y_mins[mag >= magnification_limit]
self.lensModel.set_dynamic()
return x_mins, y_mins
:return:
"""
ra_pos = kwargs_else['ra_pos']
dec_pos = kwargs_else['dec_pos']
x_pos, y_pos = self.Data.map_coord2pix(ra_pos, dec_pos)
n_points = len(x_pos)
data = self.Data.data
psf_point_source = kwargs_psf['kernel_point_source']
point_amp = kwargs_else['point_amp']
error_map = np.zeros_like(data)
if self._error_map:
for i in range(0, n_points):
error_map = self.get_error_map(data, x_pos[i], y_pos[i], psf_point_source, point_amp[i], error_map, kwargs_psf['error_map'])
grid2d = np.zeros_like(data)
for i in range(n_points):
grid2d = image_util.add_layer2image(grid2d, x_pos[i], y_pos[i], psf_point_source * point_amp[i])
point_source = grid2d
return point_source, error_map
def psf_error_map(self, ra_pos, dec_pos, amp, data, fix_psf_error_map=False):
x_pos, y_pos = self._pixel_grid.map_coord2pix(ra_pos, dec_pos)
psf_kernel = self._psf.kernel_point_source
psf_error_map = self._psf.psf_error_map
error_map = np.zeros_like(data)
for i in range(len(x_pos)):
if fix_psf_error_map:
amp_estimated = amp
else:
amp_estimated = kernel_util.estimate_amp(data, x_pos[i], y_pos[i], psf_kernel)
error_map = image_util.add_layer2image(error_map, x_pos[i], y_pos[i], psf_error_map * (psf_kernel * amp_estimated) ** 2)
return error_map
d_y = 1. / nx
y_in = np.linspace(d_y/2, 1-d_y/2, ny)
nx_new = nx * subgrid_res
ny_new = ny * subgrid_res
if odd is True:
if nx_new % 2 == 0:
nx_new -= 1
if ny_new % 2 == 0:
ny_new -= 1
d_x_new = 1. / nx_new
d_y_new = 1. / ny_new
x_out = np.linspace(d_x_new/2., 1-d_x_new/2., nx_new)
y_out = np.linspace(d_y_new/2., 1-d_y_new/2., ny_new)
kernel_input = copy.deepcopy(kernel)
kernel_subgrid = image_util.re_size_array(x_in, y_in, kernel_input, x_out, y_out)
kernel_subgrid = kernel_norm(kernel_subgrid)
for i in range(max(num_iter, 1)):
# given a proposition, re-size it to original pixel size
if subgrid_res % 2 == 0:
kernel_pixel = averaging_even_kernel(kernel_subgrid, subgrid_res)
else:
kernel_pixel = util.averaging(kernel_subgrid, numGrid=nx_new, numPix=nx)
delta = kernel - kernel_pixel
#plt.matshow(delta)
#plt.colorbar()
#plt.show()
temp_kernel = kernel_input + delta
kernel_subgrid = image_util.re_size_array(x_in, y_in, temp_kernel, x_out, y_out)#/norm_subgrid
kernel_subgrid = kernel_norm(kernel_subgrid)
kernel_input = temp_kernel