def run_scipt(): '''Run the script''' print 'Running Check Residual Script...' # Read data files. data_rec = np.load(opts.rec_data) data_noisy = np.load(opts.noise_data) psf = np.load(opts.psf) # Convolve PSF with reconstruction. data_conv = convolve(data_rec, psf, psf_type=opts.psf_type, data_format=opts.data_format) # Convert cube data to map. if opts.data_format == 'cube': if isinstance(opts.layout, type(None)): opts.layout = tuple(mfactor(data_noisy.shape[0])) data_rec = cube2map(data_rec, opts.layout) data_noisy = cube2map(data_noisy, opts.layout) data_conv = cube2map(data_conv, opts.layout) # Calculate the residual. residual = (data_noisy - data_conv) # Return all data. return (data_noisy, data_rec, data_conv, residual)
def do_stuff(): print "1- Reading full clean image data cube from file." # Read data cube binary and store first N objects. data_cube = np.load(path + data_file)[: opts.n_obj] # Save the sampled data cube sample to a binary file. if opts.save_cube: np.save(path + "deep_galaxy_cube_" + str(opts.n_obj) + ".npy", data_cube) print "2- Constructing data map from cube sample." # Find the most appropriate map layout for N objects. layout = mfactor(data_cube.shape[0]) # Transform the data cube into a map. data_map = transform.cube2map(data_cube, layout) # Save the data map to a binary file. if opts.save_map: np.save(path + "deep_galaxy_map_" + str(opts.n_obj) + ".npy", data_map) if opts.no_psf_gen: print "3- Constructing pixel variant PSF from map." # Generate the pixel variant PSF stack. psf = psf_gen.pixel_var_psf(data_map.shape, opts.variance) # Reshape the PSF stack to data cube format and save it to binary file. # Notes: The default stack is the number of map pixels, followed by the # PSF shape. The data cube format requires that the default stack be # the number of galaxies, followed by the number of pixels per galaxy # image and finally the PSF shape (hence the strange indexing below). if not opts.full_map_psf: index = np.arange(psf.shape[0]).reshape(data_map.shape) index = transform.map2cube(index, layout=layout).reshape(index.size) psf = psf[index].reshape([data_cube.shape[0]] + [np.prod(data_cube.shape[1:])] + list(psf.shape[-2:])) np.save(path + "deep_galaxy_psf_cube_" + str(opts.n_obj) + ".npy", psf) # Just save the PSF in map format to a binary file. else: np.save(path + "deep_galaxy_psf_map_" + str(opts.n_obj) + ".npy", psf)
def get_noise_est(): print '1- Estimating noise from PSF.' if opts.full_map_psf: form_tag = 'map_' else: form_tag = 'cube_' if opts.psf_type == 'fixed': psf_tag = 'fix' psf = np.load(path + opts.psf + '.npy') psf = psf_pcs.reshape([1] + list(psf_pcs)) elif opts.psf_type == 'variant': psf_tag = 'var' psf_pcs = np.load(path + 'psf_pcs_' + form_tag + str(opts.n_obj) + '.npy') psf_coef = np.load(path + 'psf_coef_' + form_tag + str(opts.n_obj) + '.npy') if not opts.full_map_psf: psf_coef = np.transpose(psf_coef, axes=[1, 0, 2, 3]) psf_coef = psf_coef.reshape([psf_coef.shape[0]] + list(mfactor(opts.n_obj) * np.array(psf_coef.shape[2:]))) kernel_shape = np.array(psf_pcs[0].shape) coef_shape = np.array(psf_coef.shape[-2:]) print coef_shape vec_length = np.prod(kernel_shape) pcst = [rot_and_roll(x.T) for x in psf_pcs] pcs = [rot_and_roll(x) for x in psf_pcs] mask = gen_mask(kernel_shape, coef_shape) k_pat = kernel_pattern(kernel_shape, mask) k_rolls = roll_sequence(kernel_shape) m_rolls = roll_sequence(mask.shape) res = [] i = 0 val = 0 widgets = ['Test: ', Percentage(), ' ', Bar(marker=RotatingMarker()), ' ', ETA(), ' ', FileTransferSpeed()] pbar = ProgressBar(widgets=widgets, maxval=10000000).start() for i in range(np.prod(coef_shape)): for k1 in range(psf_pcs.shape[0]): for k2 in range(psf_pcs.shape[0]): pkt = roll_2d(pcst[k1], roll_rad=k_rolls[k_pat[i]]).reshape(vec_length) pk = roll_2d(pcs[k2], roll_rad=k_rolls[k_pat[i]]).reshape(vec_length) mi = roll_2d(mask, roll_rad=m_rolls[i]) dk1 = psf_coef[k1][mi] dk2 = psf_coef[k2][mi] val += sum(pkt * dk1 * dk2 * pk) res.append(val) pbar.update(10*i+1) pbar.finish() res = opts.sigma ** 2 * np.array(res).reshape(coef_shape) if not opts.full_map_psf: res = transform.map2cube(res, mfactor(opts.n_obj)) np.save(path + 'psf_noise_est_' + form_tag + str(opts.n_obj)+ '_' + psf_tag + '.npy', res)
def deconvolve(): print '1- Performing deconvolution.' print ' - with mode:', opts.mode psf = None psf_pcs = None psf_coef = None if opts.full_map_psf: form_tag = 'map_' else: form_tag = 'cube_' # Read in fixed PSF file. if not isinstance(opts.psf, type(None)): psf_tag = 'fix' psf = np.load(path + opts.psf + '.npy') noise_est = opts.sigma # Read in PSF principal components and coefficients, and noise estiamte. else: psf_tag = 'var' psf_pcs = np.load(path + 'psf_pcs_' + form_tag + str(opts.n_obj) + '.npy') psf_coef = np.load(path + 'psf_coef_' + form_tag + str(opts.n_obj) + '.npy') noise_est = np.load(path + 'psf_noise_est_' + form_tag + str(opts.n_obj) + '_' + psf_tag + '.npy') # Read in noisy data file. data_noisy = np.load(path + 'deep_galaxy_noise_' + form_tag + str(opts.n_obj) + '_' + psf_tag + '.npy') # Set mr_transform wavelet type option. wavelet_opt = '-t ' + opts.wavelet_type # Perform reconstruction. layout = mfactor(opts.n_obj) # if opts.full_map_psf: # data_rec = reconstruct4.reconstruct_map(data_noisy, noise_est, layout, # psf, psf_pcs, psf_coef, # opts.wavelet_levels, # wavelet_opt, # opts.wave_thresh_factor, # opts.lowr_thresh_factor, # opts.n_reweights, opts.mode) if opts.full_map_psf: data_format = 'map' else: data_format = 'cube' primal_rec, dual_rec = reconstruct4.reconstruct(data_noisy, noise_est, layout, psf, psf_pcs, psf_coef, opts.wavelet_levels, wavelet_opt, opts.wave_thresh_factor, opts.lowr_thresh_factor, opts.n_reweights, opts.mode, opts.no_pos, data_format) # Save results to a binary file. if isinstance(opts.output, type(None)): np.save(path + 'deep_galaxy_rec_' + form_tag + str(opts.n_obj) + '_' + psf_tag + '_' + opts.mode + '.npy', primal_rec) np.save(path + 'deep_galaxy_dual_' + form_tag + str(opts.n_obj) + '_' + psf_tag + '_' + opts.mode + '.npy', dual_rec) else: np.save(path + opts.output + '_primal', primal_rec) np.save(path + opts.output + '_dual', dual_rec) if opts.full_map_psf: return (data_noisy, primal_rec) else: return (transform.cube2map(data_noisy, layout), transform.cube2map(primal_rec, layout))