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))