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