def test_rotateImage():
img = np.zeros((5, 5))
img[2, 2] = 1
img[1, 2] = 0.5
angle = 360
im_rot = image_util.rotateImage(img, angle)
npt.assert_almost_equal(im_rot[1, 2], 0.5, decimal=10)
npt.assert_almost_equal(im_rot[2, 2], 1., decimal=10)
npt.assert_almost_equal(im_rot[2, 1], 0., decimal=10)
angle = 360. / 2
im_rot = image_util.rotateImage(img, angle)
npt.assert_almost_equal(im_rot[1, 2], 0., decimal=10)
npt.assert_almost_equal(im_rot[2, 2], 1., decimal=10)
npt.assert_almost_equal(im_rot[3, 2], 0.5, decimal=10)
angle = 360. / 4
im_rot = image_util.rotateImage(img, angle)
npt.assert_almost_equal(im_rot[1, 2], 0., decimal=10)
npt.assert_almost_equal(im_rot[2, 2], 1., decimal=10)
npt.assert_almost_equal(im_rot[2, 1], 0.5, decimal=10)
angle = 360. / 8
im_rot = image_util.rotateImage(img, angle)
npt.assert_almost_equal(im_rot[1, 2], 0.23931518624017051, decimal=10)
npt.assert_almost_equal(im_rot[2, 2], 1., decimal=10)
npt.assert_almost_equal(im_rot[2, 1], 0.23931518624017073, decimal=10)
def combine_psf(kernel_list_new,
kernel_old,
sigma_bkg,
factor=1,
stacking_option='median',
symmetry=1):
"""
updates psf estimate based on old kernel and several new estimates
:param kernel_list_new: list of new PSF kernels estimated from the point sources in the image
:param kernel_old: old PSF kernel
:param sigma_bkg: estimated background noise in the image
:param factor: weight of updated estimate based on new and old estimate, factor=1 means new estimate,
factor=0 means old estimate
:param stacking_option: option of stacking, mean or median
:param symmetry: imposed symmetry of PSF estimate
:return: updated PSF estimate and error_map associated with it
"""
n = int(len(kernel_list_new) * symmetry)
angle = 360. / symmetry
kernelsize = len(kernel_old)
kernel_list = np.zeros((n, kernelsize, kernelsize))
i = 0
for kernel_new in kernel_list_new:
for k in range(symmetry):
kernel_rotated = image_util.rotateImage(kernel_new, angle * k)
kernel_norm = kernel_util.kernel_norm(kernel_rotated)
kernel_list[i, :, :] = kernel_norm
i += 1
kernel_old_rotated = np.zeros((symmetry, kernelsize, kernelsize))
for i in range(symmetry):
kernel_old_rotated[i, :, :] = kernel_old
kernel_list_new = np.append(kernel_list, kernel_old_rotated, axis=0)
if stacking_option == 'median':
kernel_new = np.median(kernel_list_new, axis=0)
elif stacking_option == 'mean':
kernel_new = np.mean(kernel_list_new, axis=0)
else:
raise ValueError(
" stack_option must be 'median' or 'mean', %s is not supported."
% stacking_option)
kernel_new[kernel_new < 0] = 0
kernel_new = kernel_util.kernel_norm(kernel_new)
kernel_return = factor * kernel_new + (1. - factor) * kernel_old
kernel_bkg = copy.deepcopy(kernel_return)
kernel_bkg[kernel_bkg < sigma_bkg] = sigma_bkg
error_map = np.var(kernel_list_new, axis=0) / kernel_bkg**2 / 2.
return kernel_return, error_map
def cutout_psf(self, x, y, image_list, kernelsize, mask, mask_point_source_list, kernel_init, symmetry=1):
"""
:param x_:
:param y_:
:param image_list: list of images (i.e. data - all models subtracted, except a single point source)
:param kernelsize:
:return:
"""
n = len(x) * symmetry
angle = 360. / symmetry
kernel_list = np.zeros((n, kernelsize, kernelsize))
i = 0
for l in range(len(x)):
# cutout the star
x_, y_ = x[l], y[l]
x_int = int(round(x_))
y_int = int(round(y_))
star_cutout = kernel_util.cutout_source(x_int, y_int, image_list[l], kernelsize + 2, shift=False)
# cutout the mask
mask_i = mask * mask_point_source_list[l]
mask_cutout = kernel_util.cutout_source(x_int, y_int, mask_i, kernelsize + 2, shift=False)
# enlarge the initial PSF kernel to the new cutout size
kernel_enlarged = np.zeros((kernelsize+2, kernelsize+2))
kernel_enlarged[1:-1, 1:-1] = kernel_init
# shift the initial kernel to the shift of the star
shift_x = x_int - x_
shift_y = y_int - y_
kernel_shifted = interp.shift(kernel_enlarged, [-shift_y, -shift_x], order=1)
# compute normalization of masked and unmasked region of the shifted kernel
# norm_masked = np.sum(kernel_shifted[mask_i == 0])
norm_unmaksed = np.sum(kernel_shifted[mask_cutout == 1])
# normalize star within the unmasked region to the norm of the initial kernel of the same region
star_cutout /= np.sum(star_cutout[mask_cutout == 1]) * norm_unmaksed
# replace mask with shifted initial kernel (+2 size)
star_cutout[mask_cutout == 0] = kernel_shifted[mask_cutout == 0]
star_cutout[star_cutout < 0] = 0
# de-shift kernel
kernel_deshifted = kernel_util.de_shift_kernel(star_cutout, shift_x, shift_y)
# re-size kernel
kernel_deshifted = image_util.cut_edges(kernel_deshifted, kernelsize)
# re-normalize kernel again
kernel_deshifted = kernel_util.kernel_norm(kernel_deshifted)
"""
kernel_shifted = kernel_util.cutout_source(x_[l], y_[l], image_list[l],
kernelsize + 2) # don't de-shift it here
mask_i = mask * mask_point_source_list[l]
mask_cutout = kernel_util.cutout_source(int(round(x_[l])), int(round(x_[l])), mask_i, kernelsize + 2,
shift=False)
kernel_shifted[kernel_shifted < 0] = 0
kernel_shifted *= mask_cutout
kernel_init = kernel_util.kernel_norm(kernel_init)
mask_cutout = image_util.cut_edges(mask_cutout, kernelsize)
kernel_shifted = image_util.cut_edges(kernel_shifted, kernelsize)
kernel_norm = np.sum(kernel_init[mask_cutout == 1])
kernel_shifted = kernel_util.kernel_norm(kernel_shifted)
kernel_shifted *= kernel_norm
kernel_shifted[mask_cutout == 0] = kernel_init[mask_cutout == 0]
#kernel_shifted[mask_cutout == 1] /= (np.sum(kernel_init[mask_cutout == 1]) * np.sum(kernel_shifted[mask_cutout == 1]))
"""
for k in range(symmetry):
kernel_rotated = image_util.rotateImage(kernel_deshifted, angle * k)
kernel_norm = kernel_util.kernel_norm(kernel_rotated)
try:
kernel_list[i, :, :] = kernel_norm
except:
raise ValueError("cutout kernel has not the same shape as the PSF."
" This is probably because the cutout of the psf hits the boarder of the data."
"Use a smaller PSF or a larger data frame for the modelling.")
i += 1
return kernel_list
