def test_raise(self):
with self.assertRaises(ValueError):
array = np.ones((2, 2, 2))
util.hard_threshold(array, 1)
with self.assertRaises(ValueError):
array = np.ones((2, 2, 2))
util.soft_threshold(array, 1)
with self.assertRaises(ValueError):
array = np.ones(5)
util.array2image(array)
with self.assertRaises(ValueError):
array = np.ones((2, 2))
util.array2cube(array, 2, 2)
with self.assertRaises(ValueError):
array = np.ones((3, 3))
util.Downsample(array, factor=2)
with self.assertRaises(ValueError):
array = np.ones((3, 3))
util.Downsample(array, factor=0.5)
with self.assertRaises(ValueError):
array = np.ones((3, 3))
util.Upsample(array, factor=0.5)
with self.assertRaises(ValueError):
util.linear_decrease(100, 200, 5, 4, 5)
with self.assertRaises(ValueError):
util.exponential_decrease(100, 200, 5, 4, 5)
with self.assertRaises(ValueError):
transform = lambda: x
inverse_transform = lambda: x
util.generate_initial_guess(99,
4,
transform,
inverse_transform,
formulation='synthesis',
guess_type='background_rms',
background_rms=0.05)
with self.assertRaises(ValueError):
transform = lambda: x
inverse_transform = lambda: x
util.generate_initial_guess(99,
4,
transform,
inverse_transform,
guess_type='something')
with self.assertRaises(ValueError):
transform = lambda: x
inverse_transform = lambda: x
util.generate_initial_guess(99,
4,
transform,
inverse_transform,
formulation='something')
def test_image2array2image():
image = np.zeros((20, 10))
nx, ny = np.shape(image)
image[1, 2] = 1
array = util.image2array(image)
image_new = util.array2image(array, nx, ny)
assert image_new[1, 2] == image[1, 2]
def test_indices_conversion():
num_pix = 99
x, y = 34, 56
i = util.index_2d_to_1d(x, y, num_pix)
x_, y_ = util.index_1d_to_2d(i, num_pix)
assert x_ == x and y_ == y
i = 254
x, y = util.index_1d_to_2d(i, num_pix)
i_ = util.index_2d_to_1d(x, y, num_pix)
assert i_ == i
x_grid_1d, y_grid_1d = util.make_grid(num_pix, deltapix=1)
x_grid_2d, y_grid_2d = util.array2image(x_grid_1d), util.array2image(
y_grid_1d)
i = 254
x, y = util.index_1d_to_2d(i, num_pix)
assert x_grid_1d[i] == x_grid_2d[x, y]
assert y_grid_1d[i] == y_grid_2d[x, y]
def project_on_original_grid(self, image):
if hasattr(self, '_reduc_indices_1d'):
input_is_1d = (len(image.shape) == 1)
array_large = np.zeros(self._num_pix**2)
if input_is_1d:
array_large[self._reduc_indices_1d] = image[:]
return array_large
else:
array_large[self._reduc_indices_1d] = util.image2array(
image)[:]
return util.array2image(array_large)
else:
return image
def _update_resized_properties(self, reduc_indices, reduced_num_pix):
self._reduc_indices_1d = util.image2array(reduc_indices).astype(bool)
# update resized coordinates
self._num_pix_resized = reduced_num_pix
self._x_grid_1d_resized = np.copy(
self._x_grid_1d[self._reduc_indices_1d])
self._y_grid_1d_resized = np.copy(
self._y_grid_1d[self._reduc_indices_1d])
# can only apply reduc_indices_1d on 1D arrays, hence reshaping operations below
effective_mask_1d = np.copy(util.image2array(self._effective_mask))
self._effective_mask_resized = util.array2image(
effective_mask_1d[self._reduc_indices_1d])
if self._verbose:
print(
"SizeablePlaneGrid: source grid has been reduced from {} to {} side pixels"
.format(self._num_pix, self._num_pix_resized))
def test_regridding_error_map_squared():
num_pix, delta_pix = 99, 0.08 # cutout pixel size
subgrid_res_source = 1
delta_pix_source = delta_pix / subgrid_res_source
delta_pix = 0.24
ra_grid, dec_grid = util.make_grid(numPix=num_pix, deltapix=delta_pix)
lens_model = LensModel(['SPEP'])
kwargs_lens = [{
'theta_E': 2,
'gamma': 2,
'center_x': 0,
'center_y': 0.1,
'e1': -0.05,
'e2': 0.05
}]
magnification_map = lens_model.magnification(ra_grid, dec_grid,
kwargs_lens)
magnification_map = util.array2image(magnification_map)
data_image = np.random.rand(num_pix, num_pix)
# when no prefactor nor mag map is passed
noise_map2_1, noise_map2_prefactor_1 \
= util.regridding_error_map_squared(data_image=data_image,
image_pixel_scale=delta_pix, source_pixel_scale=delta_pix_source)
assert noise_map2_1 is None
# when only mag map is passed
noise_map2_2, noise_map2_prefactor_2 \
= util.regridding_error_map_squared(mag_map=magnification_map, data_image=data_image,
image_pixel_scale=delta_pix, source_pixel_scale=delta_pix_source,
noise_map2_prefactor=None)
assert noise_map2_2 is not None
npt.assert_equal(noise_map2_prefactor_1, noise_map2_prefactor_2)
# when only prefactor map is passed
noise_map2_3, noise_map2_prefactor_3 \
= util.regridding_error_map_squared(mag_map=magnification_map, noise_map2_prefactor=noise_map2_prefactor_2)
assert noise_map2_3 is not None
assert noise_map2_3.shape == (num_pix, num_pix)
npt.assert_equal(noise_map2_prefactor_2, noise_map2_prefactor_3)
npt.assert_equal(noise_map2_3,
np.abs(magnification_map) * noise_map2_prefactor_2)
def setup(self):
self.num_pix = 20 # cutout pixel size
delta_pix = 0.2
_, _, ra_at_xy_0, dec_at_xy_0, _, _, Mpix2coord, _ \
= l_util.make_grid_with_coordtransform(numPix=self.num_pix, deltapix=delta_pix, subgrid_res=1,
inverse=False, left_lower=False)
# imaging data class
gaussian = Gaussian()
x, y = l_util.make_grid(self.num_pix, 1)
gaussian1 = gaussian.function(x,
y,
amp=5,
sigma=1,
center_x=-7,
center_y=-7)
gaussian2 = gaussian.function(x,
y,
amp=20,
sigma=2,
center_x=-3,
center_y=-3)
gaussian3 = gaussian.function(x,
y,
amp=60,
sigma=4,
center_x=+5,
center_y=+5)
image_data = util.array2image(gaussian1 + gaussian2 + gaussian3)
background_rms = 0.1
image_data += background_rms * np.random.randn(self.num_pix,
self.num_pix)
kwargs_data = {
'ra_at_xy_0': ra_at_xy_0,
'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord,
'image_data': image_data,
'background_rms': background_rms,
'noise_map': background_rms * np.ones_like(image_data),
}
data_class = ImageData(**kwargs_data)
# lens mass class
lens_model_class = LensModel(['SPEP'])
self.kwargs_lens = [{
'theta_E': 1,
'gamma': 2,
'center_x': 0,
'center_y': 0,
'e1': -0.05,
'e2': 0.05
}]
# source light class
source_model_class = LightModel(['SLIT_STARLETS'])
self.kwargs_source = [{
'coeffs': 0,
'n_scales': 3,
'n_pixels': self.num_pix**2
}]
# define numerics classes
image_numerics_class = NumericsSubFrame(pixel_grid=data_class,
psf=PSF(psf_type='NONE'))
source_numerics_class = NumericsSubFrame(pixel_grid=data_class,
psf=PSF(psf_type='NONE'),
supersampling_factor=1)
# init sparse solver
self.solver = SparseSolverSource(data_class,
lens_model_class,
image_numerics_class,
source_numerics_class,
source_model_class,
num_iter_source=10)
# init the plotter
self.plotter = SolverPlotter(self.solver, show_now=False)
def grid_pixels(self, two_dim=False):
theta_x_pix, theta_y_pix = self._grid.map_coord2pix(
self.theta_x, self.theta_y)
if two_dim:
return util.array2image(theta_x_pix), util.array2image(theta_y_pix)
return theta_x_pix, theta_y_pix
def grid(self, two_dim=False):
if two_dim:
return util.array2image(self.theta_x), util.array2image(
self.theta_y)
return self.theta_x, self.theta_y
def test_array2image():
array = np.linspace(1, 100, 100)
image = util.array2image(array)
assert image[9][9] == 100
assert image[0][9] == 10
def source2image_2d(self, source, **kwargs):
source_1d = util.image2array(source)
return util.array2image(self.source2image(source_1d, **kwargs))
def magnification_map(self, kwargs_lens):
mag_map_1d = self.lensModel.magnification(self.imagePlane.theta_x,
self.imagePlane.theta_y,
kwargs_lens)
return util.array2image(mag_map_1d)
def image2source_2d(self, image, **kwargs):
image_1d = util.image2array(image)
return util.array2image(self.image2source(image_1d, **kwargs))
