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