def MtX(self, x): r"""Adjoint to degradation operator :func:`MX`.""" x = utils.reg_format(x * self.SNR_weights) upsamp_x = np.array( [nf * utils.adjoint_degradation_op(x_i, shift_ker, self.D) for nf, x_i, shift_ker in zip(self.normfacs, x, utils.reg_format(self.ker_rot))]) x, upsamp_x = utils.rca_format(x), utils.rca_format(upsamp_x) return utils.apply_transform(upsamp_x.dot(self.A.T), self.filters)
def update_H_glob(self, new_H_glob): r"""Update current global model.""" self.H_glob = new_H_glob dec_H_glob = np.array( [nf * utils.degradation_op(H_i, shift_ker, self.D) for nf, shift_ker, H_i in zip(self.normfacs, utils.reg_format(self.ker), utils.reg_format(self.H_glob))]) self.FdH_glob = utils.rca_format(dec_H_glob)
def update_H_loc(self, new_H_loc): r"""Update current local models.""" self.H_loc = new_H_loc dec_H_loc = np.array([nf * utils.degradation_op(H_i, shift_ker, self.D) for nf, shift_ker, H_i in zip(self.normfacs, utils.reg_format(self.ker), utils.reg_format(self.H_loc))]) self.FdH_loc = utils.rca_format(dec_H_loc)
def update_S(self, new_S, update_spectral_radius=True): r"""Update current eigenPSFs.""" self.S = new_S self.FdS = np.array([[nf * utils.degradation_op(S_j, shift_ker, self.D) for nf, shift_ker in zip(self.normfacs, utils.reg_format(self.ker))] for S_j in utils.reg_format(self.S)]) if update_spectral_radius: PowerMethod.get_spec_rad(self)
def MtX(self, x): r"""Adjoint to degradation operator :func:`MX`. Parameters ---------- x : numpy.ndarray Set of finer-grid images. """ x = utils.reg_format(x * self.SNR_weights) # [TL] CHECK STx = np.array([np.sum(FdS_i * x, axis=(1, 2)) for FdS_i in self.FdS]) return STx.dot(self.Pi.T)
def MX(self, transf_S): r"""Apply degradation operator and renormalize. Parameters ---------- transf_S : numpy.ndarray Current eigenPSFs in Starlet space. Returns ------- numpy.ndarray result """ S = utils.rca_format( np.array([filter_convolve(transf_Sj, self.filters, filter_rot=True) for transf_Sj in transf_S])) dec_rec = np.array( [nf * utils.degradation_op(S.dot(A_i), shift_ker, self.D) for nf, A_i, shift_ker in zip(self.normfacs, self.A.T, utils.reg_format(self.ker))]) self._current_rec = utils.rca_format(dec_rec) return self._current_rec
def outlier_rejection(star_list, pos_list, mask_list, ccd_list, SNR_list=None, RA_list=None, DEC_list=None, shape_std_max=5., print_fun=None): r"""Outlier star rejection method. Notes ----- It is based on the measurements from Galsim's HSM adaptive moments. The method calculates the 2nd order moments from the stars in the exposure. If there are stars that have an aberrant value in one of the stats, e1, e2 or R2 we discard the star. An aberrant value is defined as a value that is more than ``shape_std_max`` sigmas away from the mean. It inputs all the lists that will be used as a method and returns the same lists without the stars that where considered as outliers. ``print_fun`` is a function that prints details about the stars being removed. """ # Define the printing function. Could be printing on a log file. if print_fun is None: def print_fun(msg): print(msg) # Reject outliers all_stars = np.concatenate(star_list, axis=2) all_stars = utils.reg_format(np.copy(all_stars)) all_masks = np.concatenate(mask_list, axis=2) all_masks = utils.reg_format(np.copy(all_masks)) # hsm thinks 0 means good badpix_masks = np.rint(np.abs(all_masks - 1)) star_moms = [ hsm.FindAdaptiveMom(Image(star), badpix=Image(bp), strict=False) for star, bp in zip(all_stars, badpix_masks) ] star_shapes = np.array([[ moms.observed_shape.g1, moms.observed_shape.g2, 2. * moms.moments_sigma**2, int(bool(moms.error_message)) ] for moms in star_moms]) # Outlier rejection based on e1, e2 and R2 R2_thresh = shape_std_max * np.std(star_shapes[:, 2]) + \ np.mean(star_shapes[:, 2]) R2_bad_stars = (abs(star_shapes[:, 2]) > R2_thresh) e2_thresh = shape_std_max * np.std(star_shapes[:, 1]) + \ np.mean(star_shapes[:, 1]) e2_bad_stars = (abs(star_shapes[:, 1]) > e2_thresh) e1_thresh = shape_std_max * np.std(star_shapes[:, 0]) + \ np.mean(star_shapes[:, 0]) e1_bad_stars = (abs(star_shapes[:, 0]) > e1_thresh) bad_stars = np.logical_or(e1_bad_stars, e2_bad_stars) bad_stars = np.logical_or(bad_stars, R2_bad_stars) bad_stars_idx = np.nonzero(bad_stars)[0] print_fun(bad_stars_idx) print_fun(bad_stars_idx.shape) # Create masks erase_masks = [ np.zeros(star_list[i].shape[2], dtype=bool) for i in range(len(star_list)) ] if bad_stars_idx.size > 0: # We have to erase the outliers # Create the reference ids (to match the global # array to the list of arrays) idx_ref = np.zeros((len(all_stars), 3), dtype=int) glob_id, star_id, ccd_id = 0, 0, 0 for stars in star_list: star_id = 0 for _star in utils.reg_format(stars): idx_ref[glob_id, 0] = glob_id idx_ref[glob_id, 1] = star_id idx_ref[glob_id, 2] = ccd_id glob_id += 1 star_id += 1 ccd_id += 1 # select outlier stars for bad_id in bad_stars_idx: print_fun('Outlier: Glob_id=%d , star_id=%d , ccd_id=%d' % (idx_ref[bad_id, 0], idx_ref[bad_id, 1], idx_ref[bad_id, 2])) erase_masks[idx_ref[bad_id, 2]][idx_ref[bad_id, 1]] = True for it_star in range(len(star_list)): mask = ~erase_masks[it_star] # erase elements and overwrite star_list[it_star] = star_list[it_star][:, :, mask] mask_list[it_star] = mask_list[it_star][:, :, mask] pos_list[it_star] = pos_list[it_star][mask, :] if SNR_list is not None: SNR_list[it_star] = SNR_list[it_star][mask] if RA_list is not None: RA_list[it_star] = RA_list[it_star][mask] DEC_list[it_star] = DEC_list[it_star][mask] return star_list, pos_list, mask_list, ccd_list, SNR_list, RA_list,\ DEC_list, erase_masks