def psf_gen(fit_id, params): gstrat, sfact, mpar = params['G_STRAT'], params['S_FACT'], params[ 'MOF_PARAMS'] psfsize, g_par, g_pos = params['PSF_SIZE'], params['G_PARAMS'], params[ 'G_POS'] show, objsize = params['SHOW'], params['OBJ_SIZE'] out(2, 'Initialization...') # if psfsize is None: psfsize = objsize # nx = ny = psfsize*sfact # if center == 'O': # c1, c2 = nx/2.-0.5, ny/2.-0.5 # elif center == 'NE': # c1, c2 = nx/2., ny/2. # elif center == 'SW': # c1, c2 = nx/2.-1., ny/2.-1. # psf = PSF((nx,ny), (c1,c2)) # mof = mpar[fit_id][:4] # gpos = array(g_pos)[fit_id] # gpar = array(g_par)[fit_id] # out(2, 'Building the PSF...') # psf.set_finalPSF(mof, gpar, gpos, gstrat, (c1, c2, 1.), center=center) # out(2, 'Done. Creating splitted PSF (old style shape)...') # s = fn.switch_psf_shape(psf.array, center) size = psfsize * sfact, psfsize * sfact psf, s = fn.psf_gen(size, zeros(size), mpar[fit_id][:4], array(g_par)[fit_id], array(g_par)[fit_id], gstrat, sfact) fn.array2fits(psf.array, 'results/psf_' + str(fit_id + 1) + '.fits') fn.array2fits(s, 'results/s_' + str(fit_id + 1) + '.fits') if show == True: fn.array2ds9(psf.array, name='psf') fn.array2ds9(s, name='s', frame=2)
def switch_ini(self): """ Switch the deconvolution initial parameters with the new ones """ self.refresh() self.params['INI_PAR'] = copy.deepcopy(self.params['SRC_PARAMS']) dir = 'results' if self.as_exe: dir = './' bk = fn.get_data('background.fits', dir) fn.array2fits(bk, os.path.join(dir, 'bkg_ini.fits')) self.save() out(2, 'Parameters switched')
def deconv_ini(self): """ Get the initial parameters for the deconvolution """ self.refresh() out(1, 'Begin parameters initialization') bkg, src, shifts = get_ini_par.set_ini(self.data, self.params, savedir=self.as_exe * './' or (not self.as_exe) * 'results/') out(1, 'Parameters initialization done') self.params['INI_PAR'] = src.ravel().tolist() self.params['IMG_OFFSETS'] = shifts.tolist() fn.array2fits(bkg, 'results/bkg_ini.fits') self.save()
def prompt(file=None): if file is None: file = 'gsig_1.fits' opt, args = fn.get_args(sys.argv) if args is not None: file = args[0] s = string.split(file, '_', 1) maskfile = s[0] + 'mask_' + s[1] try: mask = fn.get_data(maskfile) except: sys.stdout.write('Enter the filename of the mask: ') mask = fn.get_data(raw_input()) data = fn.get_data(file, '') fn.array2ds9(data, frame=1, name='data', zscale=True) fn.array2ds9(mask, frame=2, name='current_mask') print 'Place markers on the desired region (only circles and polygons are supported).' sys.stdout.write( '[Press ENTER when you are done (opt: enter the mask value)]') input = raw_input() if input == 'q' or input == 'quit': return 0 mask = fn.get_ds9_mask(data.shape) try: val = eval(string.strip(input)) except: val = 1.e3 print 'Using default mask value:', val print(data * mask).sum() np.putmask(data, mask, val) fn.array2ds9(mask, frame=2, name='mask') fn.array2ds9(data, frame=3, name='new_data', zscale=False) # fn.array2fits(data, file) fn.array2fits(mask.astype(np.float), maskfile)
def set_ini(data, params, savedir='results/'): #TODO: set to the new norms!! (params) def X2x(X): return X * sfact - 1. / sfact def x2X(x): return x / sfact + 1. / sfact**2. nimg, sfact, gres = params['filenb'], params['S_FACT'], params['G_RES'] show, USE_CUDA, nb_src = params['SHOW'], params['CUDA'], params['NB_SRC'] box_size, src_range, fftdiv = params['BOX_SIZE'], params[ 'SRC_RANGE'], params['FFT_DIV'] obj = [data['objs'][i][0].astype('float64') for i in xrange(nimg)] sigma = [data['objssig'][i][0].astype('float64') for i in xrange(nimg)] psf = [data['psfs'][i][0].astype('float64') for i in xrange(nimg)] bshape = obj[0].shape sshape = (int(bshape[0] * sfact), int(bshape[1] * sfact)) orig_fwhm = 4.5 # 4. #BIG pixels! ~3. if USE_CUDA and fn.has_cuda(): context, plan = fn.cuda_init(sshape) out(2, 'CUDA initializations') def convol(a, b): return fn.cuda_conv(plan, a, b) def deconv(a, b): return fn.cuda_fftdiv(plan, a, b) if not fftdiv: deconv = None else: USE_CUDA = False convol = fn.conv deconv = None out(2, 'Interpolating data...') obji = [] sigmai = [] flux_o = [] flux_s = [] for i in xrange(nimg): d_filt = signal.signaltools.wiener(obj[i], [3, 3]) # psf[i] = signal.signaltools.medfilt2d(psf[i], [3,3]) # psf[i] /= psf[i].sum() obji += [ scipy.ndimage.interpolation.zoom(d_filt, sfact, order=5, mode='reflect').astype('float64') ] sigmai += [ scipy.ndimage.interpolation.zoom(sigma[i], sfact, order=5, mode='reflect').astype('float64') ] flux_o += [obj[i].sum()] flux_s += [sigma[i].sum()] obji[i] *= flux_o[-1] / obji[i].sum() sigmai[i] *= flux_s[-1] / sigmai[i].sum() out(2, 'Setting initial sources parameters...') srcpos, ini = _get_ini(obji[0], sigmai[0], psf[0], nb_src, gres, sfact, nimg, src_range, convol, deconv, pad=box_size) shiftpar = -fn.get_shifts( obj, boxsize=10)[1:] #array([0.1 for i in xrange(2*nimg)]) shiftpar = shiftpar.ravel() fn.array2fits(ini, savedir + 'bkg_ini.fits') ws.drop('INI_PAR', srcpos) if show: fn.array2ds9(obji[0], name='data') fn.array2ds9(ini, name='background', frame=2) if USE_CUDA: out(2, 'Freeing CUDA context...') context.pop() return ini, srcpos, shiftpar
def fitnum(fit_id, data, params, savedir='results/', liveplot=False): starpos, npix, sfactor, mpar = params['STARS'], params['NPIX'], params[ 'S_FACT'], copy.deepcopy(params['MOF_PARAMS']) gres, fitrad, psf_size, itnb = params['G_RES'], params['FIT_RAD'], params[ 'PSF_SIZE'], params['MAX_IT_N'] nbruns, show, _lambda, stepfact = params['NB_RUNS'], params[ 'SHOW'], params['LAMBDA_NUM'], params['BKG_STEP_RATIO_NUM'] cuda, radius, stddev, objsize = params['CUDA'], params['PSF_RAD'], params[ 'SIGMA_SKY'], params['OBJ_SIZE'] minstep, maxstep, thresh = params['MIN_STEP_NUM'], params[ 'MAX_STEP_NUM'], params['WL_THRESHOLD_NUM'] stars = [] mofpar = Param(1, 0) bshape = data['stars'][fit_id][0].shape sshape = (int(bshape[0] * sfactor), int(bshape[1] * sfactor)) ############### Prepare the gaussian PSF ############### r_len = sshape[0] c1, c2 = r_len / 2. - 0.5, r_len / 2. - 0.5 #-0.5 to align on the pixels grid r = fn.gaussian(sshape, gres, c1, c2, 1.) # r = fn.LG_filter(sshape, gres, c1, c2) if cuda and fn.has_cuda(): out(2, 'CUDA initializations') context, plan = fn.cuda_init(sshape) r = fn.switch_psf_shape(r, 'SW') def conv(a, b): return fn.cuda_conv(plan, a, b) else: conv = fn.conv cuda = False r /= r.sum() ############### Set the smoothing ############### _lambda = fn.get_lambda(sshape, radius + 5., _lambda) sm = r.copy() # if not thresh: # thresh = params['SIGMA_SKY'] ############## Initializations ############## for i, pos in enumerate(starpos): #populates the stars array: im = Image(copy.deepcopy(data['stars'][fit_id][i]), noisemap=copy.deepcopy(data['sigs'][fit_id][i]), mask=copy.deepcopy(data['masks'][fit_id][i])) # im.shiftToCenter(mpar[fit_id][4+3*i]/sfactor,mpar[fit_id][4+3*i+1]/sfactor, center_mode='O') # mpar[fit_id][4+3*i:4+3*i+2] = sshape[0]/2., sshape[1]/2. stars += [Star(i + 1, im, mofpar, sfactor, gres, False)] mofpar.fromArray(np.array(mpar[fit_id]), i=-1) img_shifts = [] mof_err = 0. for i, s in enumerate(stars): s.moff_eval() s.build_diffm() s.image.noiseMap /= mpar[fit_id][6 + 3 * i] s.diffm.array /= mpar[fit_id][6 + 3 * i] img_shifts += [((mpar[fit_id][4 + 3 * i] - r_len / 2.), (mpar[fit_id][5 + 3 * i] - r_len / 2.))] mof_err += (np.logical_not(s.image.mask) * abs(s.diffm.array / s.image.noiseMap)).sum() ############ Deconvolution ############ # dec = DecCLEAN([s.diffm.array for s in stars], # dec = DecMC([s.diffm.array for s in stars], # dec = DecWL([s.diffm.array for s in stars], # dec = DecML([s.diffm.array for s in stars], dec = Dec([s.diffm.array for s in stars], [s.image.noiseMap for s in stars], [s.image.mask for s in stars], r, sm, conv, img_shifts, _lambda, gres, thresh) # bak = dec.deconv() dec.ini *= fn.get_circ_mask_exp(dec.ini.shape, radius) bak = dec.deconv(itnb, minstep, maxstep, stepfact, radius) # bak = cyclespin(bak, 3, dec._get_dn_threshold(bak)[0]*10.) bak_conv = conv(r, bak) bak *= fn.get_circ_mask_exp(bak.shape, radius) #, exp=4.) ########## gaus_err = 0. for i, im in enumerate(stars): gaus_err += abs(dec.get_im_resi(bak_conv, i)).sum() out(2, "indicative error gain:", 100 * (1. - gaus_err / mof_err), "%") ########## Set the numerical PSF ########## out(2, 'Building the final PSF...') if psf_size is None: psf_size = objsize size = psf_size * sfactor, psf_size * sfactor psf, s = fn.psf_gen(size, bak, mpar[fit_id][:4], [[]], [[]], 'mixed', sfactor) ############ Prepare output ############ imgs, names = [], [] imgs += [psf.array, s, bak, dec.ini] names += [ 'psf_' + str(fit_id + 1), 's_' + str(fit_id + 1), 'psf_num_' + str(fit_id + 1), 'psfnum_ini_' + str(fit_id + 1) ] for i, s in enumerate(stars): resi = dec.get_im_resi(bak_conv, i, ret_all=True)[1] imgs += [s.diffm.array, resi] names += [ "difmof%(fnb)02d_%(n)02d" % { 'fnb': fit_id + 1, 'n': s.id }, "difnum%(fnb)02d_%(n)02d" % { 'fnb': fit_id + 1, 'n': s.id } ] ############ Save and display ############ if savedir is not None: out(2, 'Writing to disk...') for i, im in enumerate(imgs): fn.array2fits(im, savedir + names[i] + '.fits') # fn.save_img(imgs, names, savedir+'overview.png', min_size=(256,256)) if show == True: out(2, 'Displaying results...') for i, im in enumerate(imgs): fn.array2ds9(im, name=names[i], frame=i + 1) import pylab as p p.figure() trace = np.array(dec.trace) X = np.arange(trace.shape[0]) p.title('Error evolution') p.plot(X, trace) # p.legend() p.draw() p.savefig(savedir + 'trace_fitnum%(fnb)02d.png' % {'fnb': fit_id + 1}) if show == True: p.show() if cuda: out(2, 'Freeing CUDA context...') context.pop() return 0
def deconv(data, params, savedir='results/'): global err, old_bkg, TRACE, TRACE2, err_bk, err_sm err = old_bkg = None sfact, gres, itnb, mpar = params['S_FACT'], params['G_RES'], params[ 'MAX_IT_D'], params['MOF_PARAMS'] gstrat, gpar, gpos = params['G_STRAT'], params['G_PARAMS'], params['G_POS'] show, maxpos_range, stddev = params['SHOW'], params[ 'MAXPOS_RANGE'], params['SIGMA_SKY'] max_iratio_range, force_ini = params['MAX_IRATIO_RANGE'], params[ 'FORCE_INI'] bkg_ini, stepfact, bkg_ratio = params['BKG_INI_CST'], params[ 'BKG_STEP_RATIO'], params['BKG_START_RATIO'] _lambda, nbruns, nb_src = params['LAMBDA'], params['D_NB_RUNS'], params[ 'NB_SRC'] box_size, src_range, cuda = params['BOX_SIZE'], params[ 'SRC_RANGE'], params['CUDA'] srcini, minstep_px, maxstep_px = params['INI_PAR'], params[ 'MIN_STEP_D'], params['MAX_STEP_D'] thresh = params['WL_THRESHOLD_DEC'] out(2, 'Initialization') nimg = params['filenb'] objs = [data['objs'][i][0].astype('float64') for i in xrange(nimg)] sigmas = [data['objssigs'][i][0].astype('float64') for i in xrange(nimg)] masks = [data['objsmasks'][i][0].astype('float64') for i in xrange(nimg)] psfs = [data['psfs'][i][0].astype('float64') for i in xrange(nimg)] dev = stddev[0] mpar = mpar[0] gpar = gpar[0] gpos = gpos[0] bshape = objs[0].shape sshape = (int(bshape[0] * sfact), int(bshape[1] * sfact)) sources = [ PSF(sshape, (sshape[0] / 2., sshape[1] / 2.)) for i in xrange(nimg) ] ############### Prepare the gaussian PSF ############### r_len = sshape[0] c1, c2 = r_len / 2. - 0.5, r_len / 2. - 0.5 #-0.5 to align on the pixels grid r = fn.gaussian(sshape, gres, c1, c2, 1.) # r = fn.LG_filter(sshape, gres, c1, c2) if cuda and fn.has_cuda(): out(2, 'CUDA initializations') context, plan = fn.cuda_init(sshape) r = fn.switch_psf_shape(r, 'SW') def conv(a, b): return fn.cuda_conv(plan, a, b) def div(a, b): return fn.cuda_fftdiv(plan, a, b) psfs = [fn.switch_psf_shape(p, 'SW') for p in psfs] else: conv = fn.conv div = None #fn.div cuda = False r /= r.sum() div = None ########## Initializations ########## img_shifts = fn.get_shifts(objs, 10.) _lambda = fn.get_lambda(sshape, None, _lambda) # if not thresh: # thresh = params['SIGMA_SKY'] dec = DecSrc(objs, sigmas, masks, psfs, r, conv, img_shifts, _lambda, gres, thresh, nb_src, srcini, box_size, src_range, force_ini, bkg_ini, bkg_ratio) ########## Deconvolution ########## bak, src_par = dec.deconv(itnb, minstep_px, maxstep_px, maxpos_range, max_iratio_range, stepfact, nbruns) out(2, 'Initial sources parameters [x,y,I]:', dec.src_ini) out(2, 'Final sources parameters [x,y,I]:', src_par) out(2, 'offsets:', dec.shifts) ############ Prepare output ############ imgs, names = [], [] imgs += [bak, dec.ini] names += ['background', 'bkg_ini'] dec.set_sources(src_par, bak) for i in xrange(len(objs)): bak_conv = conv(dec.psfs[i], bak + dec.sources[i].array) resi = dec.get_im_resi(bak_conv, i) imgs += [ objs[i], resi, dec.sources[i].array, bak + dec.sources[i].array ] names += [ "g_" + str(i + 1), "resi_%(fnb)02d" % { 'fnb': i + 1 }, "sources_%(fnb)02d" % { 'fnb': i + 1 }, "deconv_%(fnb)02d" % { 'fnb': i + 1 } ] ############ Save and display ############ if savedir is not None: out(2, 'Writing to disk...') for i, im in enumerate(imgs): fn.array2fits(im, savedir + names[i] + '.fits') # fn.save_img(imgs, names, savedir+'overview.png', min_size=(256,256)) if show == True: out(2, 'Displaying results...') for i, im in enumerate(imgs): fn.array2ds9(im, name=names[i], frame=i + 1) import pylab as p p.figure(1) trace = array(dec.trace) X = arange(trace.shape[0]) p.title('Error evolution') p.plot(X, trace) # p.legend() p.draw() p.savefig(savedir + 'trace_deconv.png') if show == True: p.show() if cuda: out(2, 'Freeing CUDA context...') context.pop() return src_par, dec.shifts, dec.src_ini