def main():
args = get_args()
rng = np.random.RandomState(args.seed)
obs, gm = make_data(rng=rng, noise=args.noise)
guess = gm.copy()
randomize_gmix(rng=rng, gmix=guess, pixel_scale=obs.jacobian.scale)
res = ngmix.em.run_em(obs=obs, guess=guess)
gmfit = res.get_gmix()
print('true gm:')
print(gm)
print('fit gm:')
print(gmfit)
if args.show:
try:
import images
except ImportError:
from espy import images
imfit = res.make_image()
images.compare_images(obs.image, imfit)
return gmfit
def _make_symmetrized_image(im_input):
"""
add a version of itself roated by 90,180,270 degrees
"""
im = im_input.copy()
im += numpy.rot90(im_input, k=1)
im += numpy.rot90(im_input, k=2)
im += numpy.rot90(im_input, k=3)
im *= (1.0/4.0)
if False:
import images
images.multiview(im)
images.compare_images(
im_input,
im,
label1='orig',
label2='symm',
width=1000,
height=1000,
)
if 'q'==raw_input('hit a key: '):
stop
return im
def _make_symmetrized_image(im_input):
"""
add a version of itself roated by 90,180,270 degrees
"""
im = im_input.copy()
im += numpy.rot90(im_input, k=1)
im += numpy.rot90(im_input, k=2)
im += numpy.rot90(im_input, k=3)
im *= (1.0 / 4.0)
if False:
import images
images.multiview(im)
images.compare_images(
im_input,
im,
label1='orig',
label2='symm',
width=1000,
height=1000,
)
if 'q' == raw_input('hit a key: '):
stop
return im
def _fit_psf_model_lm(self, im, ares, model, skysig):
"""
Returns the fitter object
"""
if model == "gmix1":
ngauss = 1
elif model == "gmix2":
ngauss = 2
elif model == "gmix3":
ngauss = 3
else:
raise ValueError("bad psf model: '%s'" % model)
ntry = 1
gm = None
while ntry <= self["psf_lm_ntry"]:
tmp = gmix_image.gmix_fit.quick_fit_psf_coellip(im, skysig, ngauss, ares=ares)
if tmp is None:
continue
if tmp.flags == 0:
gm = tmp
break
ntry += 1
if self["make_psf_plots"] and gm is not None:
import images
model = gmix_image.render.gmix2image(gm.get_gmix(), im.shape)
images.compare_images(im, model, label1="image", label2="model")
key = raw_input("hit a key (q to quit): ")
if key == "q":
stop
return gm
def main():
args = get_args()
rng = np.random.RandomState(args.seed)
obs, gm = make_data(rng=rng, noise=args.noise)
# use a psf guesser
guesser = ngmix.guessers.GMixPSFGuesser(rng=rng, ngauss=1)
guess = guesser(obs=obs)
res = ngmix.em.run_em(obs=obs, guess=guess)
gmfit = res.get_gmix()
print('true gm:')
print(gm)
print('fit gm:')
print(gmfit)
if args.show:
try:
import images
except ImportError:
from espy import images
imfit = res.make_image()
images.compare_images(obs.image, imfit)
return gmfit
def _fit_psf_model_em(self, im, ares, model, skysig):
"""
Returns the fitter object
"""
if model == "em1":
ngauss = 1
elif model == "em2":
ngauss = 2
elif model == "em3":
ngauss = 3
else:
raise ValueError("bad psf model: '%s'" % model)
ivar = 1.0 / skysig ** 2
gm = GMixEMPSF(im, ivar, ngauss, ares=ares, maxtry_em=self["psf_em_ntry"])
res = gm.get_result()
if self["make_psf_plots"] and res["flags"] == 0:
import images
model = gmix_image.render.gmix2image(gm.get_gmix(), im.shape)
images.compare_images(im, model, label1="image", label2="model")
key = raw_input("hit a key (q to quit): ")
if key == "q":
stop
return gm
def get_target_image(self, psf_obj, shear=None):
"""
get the target image, convolved with the specified psf
and possibly sheared
parameters
----------
psf_obj: A galsim object
psf object by which to convolve. An interpolated image,
or surface brightness profile
shear: ngmix.Shape, optional
The shear to apply
returns
-------
galsim image object
"""
imconv = self._get_target_gal_obj(psf_obj, shear=shear)
# this should carry over the wcs
#newim = self.image.copy()
#imconv.drawImage(
# image=newim,
# method='no_pixel' # pixel is in the PSF
#)
ny, nx = self.image.array.shape
try:
newim = imconv.drawImage(
nx=nx,
ny=ny,
#scale=0.263,
wcs=self.image.wcs,
dtype=numpy.float64,
)
except RuntimeError as err:
# argh, galsim uses generic exceptions
raise GMixRangeError("galsim error: '%s'" % str(err))
if False:
import images
print()
print("imconv:", imconv)
print()
print(newim.array.shape, newim.array.dtype)
print("imsum:", newim.array.sum())
print()
images.compare_images(
self.image.array,
newim.array,
label1='image',
label2='reconvolved',
file='/u/ki/esheldon/public_html/tmp/plots/tmp.png',
)
if 'q' == raw_input('hit a key: '):
stop
return newim
def test_gmix_exp():
from fimage import model_image
numpy.random.seed(35)
ngauss=3
nsig=7.
#dims=[41,41]
#cen=[(dims[0]-1)/2., (dims[1]-1)/2.]
#cov=[10.5,0.0,10.5]
T = 2*3
e = 0.3
theta = randu()*360.
e1 = e*cos(2*theta*numpy.pi/180.0)
e2 = e*sin(2*theta*numpy.pi/180.0)
Irc = e2*T/2.0
#Icc = (1+e1)*T/2.0
#Irr = (1-e1)*T/2.0
Icc = (1+e1)*T/2.0
Irr = (1-e1)*T/2.0
#T = 2.*3.0
sigma = sqrt(T/2.)
dim = int(2*nsig*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
print 'dims:',dims
cen=(dims-1)/2.
#cov = [T/2.,0.0,T/2.]
cov = [Irr,Irc,Icc]
# need order='c' since we will use in in C code!
im = model_image('exp',dims,cen,cov,order='c')
sky = 0.01*im.max()
im_fakesky = im + sky
ntry=0
max_try = 10
flags=9999
while flags != 0 and ntry < max_try:
stderr.write('.')
guess = get_exp_guess(cen,cov,ngauss)
gm=gmix_image.GMixEM(im_fakesky, guess, sky=sky, maxiter=5000)
flags = gm.flags
ntry += 1
if ntry == max_try:
raise ValueError("too many tries")
gmix_image.gmix_print(gm.pars)
stderr.write('\n')
model = gmix2image_em(gm.pars,im.shape)
images.compare_images(im, model)
def test_em_sdss(ngauss=2,
run=756,
field=45,
camcol=1,
filter='r',
row=123.1,
col=724.8,
cocenter=False,
show=False):
import sdsspy
fnum=sdsspy.FILTERNUM[filter]
psfield=sdsspy.read('psField', run=run, camcol=camcol, field=field,
lower=True)
psfkl=sdsspy.read('psField', run=run, camcol=camcol, field=field,
filter=filter)
if psfkl is None:
print 'no such field'
return
im_nonoise=psfkl.rec(row, col, trim=True)
im0,skysig=add_noise_matched(im_nonoise, 1.e8)
ivar=1./skysig**2
dims=im0.shape
cen=[(dims[0]-1.)/2., (dims[1]-1.)/2.]
fwhm=psfield['psf_width'][0,fnum]
sigma_guess=fimage.fwhm2sigma(fwhm)
sigma_guess /= 0.4 # pixels
print 'guess fwhm:',fwhm
gm=gmix_image.gmix_em.GMixEMBoot(im0, ngauss, cen,
sigma_guess=sigma_guess,
ivar=ivar,
cocenter=cocenter)
res=gm.get_result()
gmx=gm.get_gmix()
print 'numiter:',res['numiter']
if show and have_images:
import biggles
biggles.configure('screen','width',1000)
biggles.configure('screen','height',1000)
mod=gmix2image(gmx,im0.shape)
counts=im0.sum()
mod *= counts/mod.sum()
if cocenter:
title='cocenter ngauss: %d' % ngauss
else:
title='free centers: %d' % ngauss
images.compare_images(im0, mod, label1='image',label2='model',
title=title)
print gmx
return res
def _compare_images(self, im1, im2, **keys):
import images
keys['width']=1000
keys['height']=1000
images.compare_images(im1, im2,
**keys)
key=raw_input('hit a key: ')
if key=='q':
stop
def show(self):
import images
if hasattr(self.gm,'popt'):
pars=self.gm.popt
else:
pars=self.gm.get_pars()
model=gmix2image(pars,self.psf.shape, coellip=True)
#print((model-self.psf).max())
#images.multiview(self.psf)
#images.multiview(model)
#model *= self['counts']/model.sum()
images.compare_images(self.psf, model)
def test_interpolate_gauss_image(show=False):
"""
test that our interpolation works decently for a linear
piece missing from a gaussian image
"""
noise = 0.001
sigma = 4.0
is2 = 1.0 / sigma**2
dims = 51, 51
cen = (np.array(dims) - 1.0) / 2.0
rows, cols = np.mgrid[0:dims[0], 0:dims[1], ]
rows = rows - cen[0]
cols = cols - cen[1]
image_unmasked = np.exp(-0.5 * (rows**2 + cols**2) * is2)
weight = image_unmasked * 0 + 1.0 / noise**2
badcol = int(cen[1] - 3)
bw = 3
rr = badcol - bw, badcol + bw + 1
weight[rr[0]:rr[1], badcol] = 0.0
image_masked = image_unmasked.copy()
image_masked[rr[0]:rr[1], badcol] = 0.0
bmask = np.zeros_like(image_unmasked, dtype=np.int32)
bad_flags = 0
msk = (weight <= 0) | ((bmask & bad_flags) != 0)
assert np.any(msk)
iimage = interp_image_nocheck(image=image_masked, bad_msk=msk)
maxdiff = np.abs(image_unmasked - iimage).max()
if show:
import images
images.view_mosaic([image_masked, weight])
images.compare_images(
image_unmasked,
iimage,
width=2000,
height=int(2000 * 2 / 3),
)
print('max diff:', maxdiff)
assert maxdiff < 0.0015
def lucy_richardson_deconvolution(g,h,eps =0, original=None, N=0):
#n - iterations count
f=np.copy(g)
f_prev=np.zeros(f.shape, dtype=float)
k=images.compare_images(f_prev, f)
err=[]
i=0
while(True):
f_prev=np.copy(f)
k1=conv.convolution2(f,h)
#k1=k1[h.shape[0]//2:f.shape[0]+h.shape[0]//2, h.shape[1]//2:f.shape[1]+h.shape[1]//2]
k2=g/k1
h1=np.flipud(np.fliplr(h))
del k1
k3=conv.convolution2(k2,h1)
del k2
del h1
#k3 = k3[h.shape[0] // 2:f.shape[0] + h.shape[0] // 2, h.shape[1] // 2:f.shape[1] + h.shape[1] // 2]
f=f*k3
k_prev=k
k=images.compare_images(f_prev, f)
err.append(images.compare_images(f[h.shape[0]//2:original.shape[0]+h.shape[0]//2,
h.shape[1]//2:original.shape[1] + h.shape[1]//2],
original))
if(eps!=0 and (k<eps or k_prev<k)):
print 'eps break'
break
if(N!=0 and not(i<N)):
print 'N break'
break
if N!=0:
print i
if eps!=0:
print k
i+=1
gc.collect()
#print k
err=np.array(err)
plt.figure()
plt.plot(np.arange(err.size), err)
plt.xlabel('iteration')
plt.ylabel('dif')
plt.title('compare f(i) and original image')
plt.show()
return f
def process_image(self, image, ngauss, cen, cov, psf=None,
coellip=False, cocenter=False, show=False):
im=image.copy()
# need no zero pixels and sky value
im_min = im.min()
if im_min <= 0:
im -= im_min
sky=0.001*im.max()
im += sky
else:
sky = im_min
# In the iteration, we can sometimes run into negative determinants.
# we will retry a few times with different random offsets in that case
flags = GMIXEM_ERROR_NEGATIVE_DET
ntry=0
while flags == GMIXEM_ERROR_NEGATIVE_DET and ntry < self['max_retry']:
guess = self.get_guess(ngauss, cen, cov)
gm = gmix_image.GMixEM(im,guess,
sky=sky,
maxiter=self['gmix_maxiter'],
tol=self['gmix_tol'],
coellip=coellip,
cocenter=cocenter,
psf=psf,
verbose=self['verbose'])
flags = gm.flags
#stderr.write("gmix niter: %d\n" % gm.numiter)
ntry += 1
#stderr.write("ntry: %d " % ntry)
out={'gmix': gm.pars,
'flags': gm.flags,
'numiter':gm.numiter,
'fdiff':gm.fdiff,
'ntry':ntry}
if flags == 0 and show:
print 'psf'
pprint(psf)
print 'gmix'
pprint(out['gmix'])
imrec=gmix_image.gmix2image(out['gmix'], image.shape,
psf=psf,counts=image.sum())
images.compare_images(image,imrec,
label1='image',label2='%d gauss' % ngauss)
return out
def make_plots(self):
import images
burnp, histp=self.fitter.make_plots(separate=True,
show=False,
fontsize_min=0.2)
gmix0=self.fitter.get_gmix()
gmix=gmix0.convolve(self.psf_gmix)
model_image=gmix.make_image(self.image.shape,
jacobian=self.jacobian)
residp = images.compare_images(self.image, model_image,
label1='image',
label2='model',
show=False)
print(self.burn_png)
burnp.write_img(1800,1000,self.burn_png)
print(self.hist_png)
histp.write_img(1800,1000,self.hist_png)
print(self.resid_png)
residp.write_img(1800,1000,self.resid_png)
def _compare_psf(self, fitter, model):
"""
compare psf image to best fit model
"""
import images
from ngmix.em import GMixEM
psf_image=self.psf_obs.image
if isinstance(fitter,GMixEM):
model_image = fitter.make_image(counts=psf_image.sum())
else:
gmix=fitter.get_gmix()
model_image=gmix.make_image(psf_image.shape,
jacobian=self.psf_obs.jacobian)
plt=images.compare_images(psf_image,
model_image,
label1='psf',
label2=self.conf['psf_model'],
show=False)
pname='psf-resid-%s-%06d.png' % (model, self.index)
print(" ",pname)
plt.write_img(1400,800,pname)
def _compare_gal(self, fitter):
"""
compare psf image to best fit model
"""
import images
model = self['fit_model']
title = '%d %s' % (self.mindex, model)
gmix = fitter.get_gmix()
obs = self._get_observation()
res = self.res
psf_gmix = res['psf_gmix']
gmix_conv = gmix.convolve(psf_gmix)
image = obs.image
model_image = gmix_conv.make_image(image.shape, jacobian=obs.jacobian)
plt = images.compare_images(image,
model_image,
label1='galaxy',
label2=model,
show=False)
plt.title = title
pname = 'gal-resid-%06d-%s.png' % (self.mindex, model)
resid_std = (image - model_image).std()
print(" residual std:", resid_std)
print(" ", pname)
plt.write_img(1400, 800, pname)
def _compare_gal(self, fitter):
"""
compare psf image to best fit model
"""
import images
model=self['fit_model']
title = '%d %s' % (self.mindex, model)
gmix = fitter.get_gmix()
obs = self._get_observation()
res=self.res
psf_gmix = res['psf_gmix']
gmix_conv = gmix.convolve(psf_gmix)
image=obs.image
model_image = gmix_conv.make_image(image.shape,
jacobian=obs.jacobian)
plt=images.compare_images(image,
model_image,
label1='galaxy',
label2=model,
show=False)
plt.title=title
pname='gal-resid-%06d-%s.png' % (self.mindex,model)
resid_std = (image-model_image).std()
print(" residual std:",resid_std)
print(" ",pname)
plt.write_img(1400,800,pname)
def compare_gal(self):
"""
compare psf image to best fit model
"""
import images
fitter=self.gal_fitter
model=self['model_pars']['model']
title = '%d %s' % (self.mindex, model)
gmix = fitter.get_gmix()
obs = self.obs
res=fitter.get_result()
psf_gmix = self.psf_obs.get_gmix()
gmix_conv = gmix.convolve(psf_gmix)
image=obs.image
model_image = gmix_conv.make_image(image.shape,
jacobian=obs.get_jacobian())
plt=images.compare_images(image,
model_image,
label1='galaxy',
label2=model,
show=False)
plt.title=title
pname='gal-resid-%06d-%s.png' % (self.mindex,model)
resid_std = (image-model_image).std()
print(" residual std:",resid_std)
print(" ",pname)
plt.write_img(1400,800,pname)
def compare_psf(self):
"""
compare psf image to best fit model
"""
import images
fitter=self.psf_fitter
model=self['psf_pars']['model']
obs=self.psf_obs
if 'em' in model:
model_image = fitter.make_image(counts=obs.image.sum())
else:
gm=fitter.get_gmix()
j=obs.get_jacobian()
model_image = gm.make_image(obs.image.shape,
jacobian=j)
plt=images.compare_images(obs.image,
model_image,
label1='psf',
label2=model,
show=False)
pname='psf-resid-%s-%06d.png' % (model, self.mindex)
print(" ",pname)
plt.write_img(1400,800,pname)
def compare_gal(self):
"""
compare psf image to best fit model
"""
import images
fitter = self.gal_fitter
model = self['model_pars']['model']
title = '%d %s' % (self.mindex, model)
gmix = fitter.get_gmix()
obs = self.obs
res = fitter.get_result()
psf_gmix = self.psf_obs.get_gmix()
gmix_conv = gmix.convolve(psf_gmix)
image = obs.image
model_image = gmix_conv.make_image(image.shape,
jacobian=obs.get_jacobian())
plt = images.compare_images(image,
model_image,
label1='galaxy',
label2=model,
show=False)
plt.title = title
pname = 'gal-resid-%06d-%s.png' % (self.mindex, model)
resid_std = (image - model_image).std()
print(" residual std:", resid_std)
print(" ", pname)
plt.write_img(1400, 800, pname)
def compare_psf(self):
"""
compare psf image to best fit model
"""
import images
fitter = self.psf_fitter
model = self['psf_pars']['model']
obs = self.psf_obs
if 'em' in model:
model_image = fitter.make_image(counts=obs.image.sum())
else:
gm = fitter.get_gmix()
j = obs.get_jacobian()
model_image = gm.make_image(obs.image.shape, jacobian=j)
plt = images.compare_images(obs.image,
model_image,
label1='psf',
label2=model,
show=False)
pname = 'psf-resid-%s-%06d.png' % (model, self.mindex)
print(" ", pname)
plt.write_img(1400, 800, pname)
def do_regauss(self):
self['rgstats'] = None
if 'imstats' not in self or 'psfstats' not in self:
raise ValueError("run admom on image and psf first")
if self['imstats']['whyflag'] != 0:
if self.verbose:
print("admom failed, cannot run regauss")
return
self.make_f0()
if self.f0 == None:
self['rgstats'] = {'f0flags':2**0}
return
self.make_epsilon()
self.make_f0conv()
self.iprime = self.image - self.f0conv
if self.debug:
import images
images.compare_images(self.image,
self.iprime,
label1='original',
label2='minus f0conv')
k=raw_input('hit a key (q to quit): ')
if k=='q':
stop
guess = (self['imstats']['Irr'] + self['imstats']['Irr'])/2
wrow = self['imstats']['wrow']
wcol = self['imstats']['wcol']
out = admom.admom(self.iprime,
wrow,
wcol,
sky=0.0,
sigsky=self.sigsky,
guess=guess)
out['f0flags'] = 0
self['rgstats'] = out
if self.verbose:
print("rgstats:")
pprint(self['rgstats'])
def make_epsilon(self):
"""
make a model image for the fit gaussian and subtract it from the
psf.
This becomes a convolution kernel on our simplified model for the galaxy
Note psf and the subtracted gaussian are both normalized to 1, and
epsilon thus integrates to zero
"""
import fimage
if 'psfstats' not in self:
raise ValueError("run admom on psf first")
pstats=self['psfstats']
Irr = pstats['Irr']
Irc = pstats['Irc']
Icc = pstats['Icc']
#row = (self.psf.shape[0]-1)/2
#col = (self.psf.shape[1]-1)/2
row = pstats['wrow']
col = pstats['wcol']
#print('row:',row,'col:',col)
#print('wrow:',pstats['wrow'],'wcol:',pstats['wcol'])
gauss = fimage.model_image('gauss',
self.psf.shape,
[row,col],
[Irr,Irc,Icc],
nsub=1,
counts=1)
# need both our gaussian and the psf to be normalized
tpsf = self.psf/self.psf.sum()
if self.debug:
import images
images.compare_images(tpsf, gauss, label1='psf',label2='gauss')
epsilon = tpsf - gauss
self.epsilon = epsilon
def test_fit_exp_simple(s2n=1.e5):
import biggles
import admom
import fimage
numpy.random.seed(35)
e = 0.2
theta = 23.7
e1,e2 = etheta2e1e2(e,theta)
sigma=4.0
sigma_psf = sigma/2.
fwhm_psf = 2.35*sigma_psf
print >>stderr,"e:",e,"e1:",e1,"e2:",e2
print '-'*70
print 'sigma:',sigma
T = 2*sigma**2
cov = ellip2mom(T, e=e, theta=theta)
ci=fimage.convolved.ConvolverTurbulence({'model':'exp', 'cov':cov},
{'model':'turb','psf_fwhm':fwhm_psf})
cin=fimage.convolved.NoisyConvolvedImage(ci, s2n, 1.e6)
cen=cin['cen']
gmpsf=gmix_image.gmix_em.GMixEMBoot(cin.psf, 2, cen)
gmix_psf=gmpsf.get_gmix()
ares = admom.admom(cin.image,cen[0],cen[1],guess=T/2,nsub=16)
verbose=False
skysig=cin['skysig']
gf=gmix_fit.GMixFitSimple(cin.image, 1./skysig**2, gmix_psf, 'exp', ares)
res=gf.get_result()
print 'chi2/deg:',res['chi2per']
model = gf.get_model()
images.compare_images(cin.image,model)
def test_conv_exp_gauss():
'''
Generate hires objects, convolve them with fft, and
compare to the conv_exp_gauss.
Then rebin the hires and compare to conv_exp_gauss created
at the lower res
'''
fac=5
cov=array([2.0,0.5,1.0])
psf_cov = array([1.0,0.0,1.0])
objpars_hires={'model':'exp', 'cov':cov*fac**2}
psfpars_hires={'model':'gauss', 'cov':psf_cov*fac**2}
ci_fft = ConvolvedImage(objpars_hires, psfpars_hires, conv='fft')
ci_int = ConvolvedImage(objpars_hires, psfpars_hires, conv='fconvint', fconvint_nsub=1)
images.compare_images(ci_fft.image, ci_int.image, label1='fft', label2='int')
def show_residual(self, ci, psfmix, objmix=None):
"""
Show plots of the input compared with the fit gaussian mixtures.
"""
psfmodel = gmix_image.gmix2image(psfmix,ci.psf.shape,
counts=ci.psf.sum())
images.compare_images(ci.psf,psfmodel,
label1='psf',label2='gmix')
if objmix is not None:
skysig=None
if ci['skysig'] > 0:
skysig=ci['skysig']
model0 = gmix_image.gmix2image(objmix,ci.image0.shape,
counts=ci.image0.sum())
model = gmix_image.gmix2image(objmix,ci.image.shape,
psf=psfmix,
counts=ci.image.sum())
images.compare_images(ci.image0,model0,
label1='object0',label2='gmix',
skysig=skysig)
images.compare_images(ci.image,model,
label1='object+psf',label2='gmix',
skysig=skysig)
stop
def doplot(self, show=False):
import images
gm=self._fitter.get_gmix()
model=gm.make_image(self.p.shape, jacobian=self.jacobian)
plt=images.compare_images(self.p, model,
label1='p(g1,g2)',
label2='model',
show=show)
return plt
def new_random_convolved_image(self, ellip):
p = self.rsp.get()
psfpars={'model':'dgauss',
'Irr1':p['sigma1']**2,
'Irc1':0.0,
'Icc1':p['sigma1']**2,
'sizerat': p['sigma2']/p['sigma1'],
'cenrat': p['b'],
'dims': [31,31],
'cen':[15,15]}
# parameters for a model galaxy of the right size
# just relative to the first, dominant one
Tobj = (psfpars['Irr1']+psfpars['Icc1'])/self['s2']
# random angle
theta = numpy.random.random()*360
Irr,Irc,Icc = fimage.ellip2mom(Tobj, e=ellip, theta=theta)
objpars={'model':self['objmodel'],
'Irr':Irr,
'Irc':Irc,
'Icc':Icc}
ci = fimage.ConvolvedImage(objpars, psfpars, conv=self['conv'])
ci['theta'] = theta
if self['debug']:
self.rsp.load_kl(self.rsp.current_i)
psf = self.rsp.kl.rec(1000,1000, trim=True)
images.compare_images(ci.psf, psf)
ci.show()
key=raw_input('hit a key: ')
self.rsp.next()
return ci
def compare_gmix_approx(type, s2):
import fimage
from .render import gmix2image
from .gmix import GMixCoellip, GMixDev, GMixExp
import images
Tpsf=3.9
Tobj=Tpsf/s2
objpars = {'model':type, 'cov':[Tobj/2.,0.0,Tobj/2.]}
psfpars = {'model':'gauss', 'cov':[Tpsf/2.,0.0,Tpsf/2.]}
ci0=fimage.convolved.ConvolverGaussFFT(objpars,psfpars)
ci = fimage.convolved.TrimmedConvolvedImage(ci0, fluxfrac=.9997)
cen=ci['cen']
psfcen=ci['cen_psf_uw']
if type=='dev':
gmix = GMixDev( [cen[0],cen[1], 0., 0., Tobj, 1.] )
elif type=='exp':
gmix = GMixExp( [cen[0],cen[1], 0., 0., Tobj, 1.] )
else:
raise ValueError("bad type: '%s'" % type)
psf_gauss = GMixCoellip( [psfcen[0],psfcen[1], 0., 0., Tpsf, 1.] )
obj = gmix.convolve(psf_gauss)
psf=gmix2image(psf_gauss,ci.image.shape,nsub=16)
im=gmix2image(obj,ci.image.shape,nsub=16)
im *= 1.0/im.sum()
imdev = ci.image*1.0/ci.image.sum()
images.compare_images(ci.psf, psf,
label1='psf0', label2='psf')
images.compare_images(imdev, im,
label1='%s fft' % type, label2='%s gmix' % type)
def _do_plots(im, gm, expname, ccd, pos, offset, png_path):
model=gm.get_model()
model *= im.sum()/model.sum()
plt=images.compare_images(im*100, model*100,
label1='image',
label2='model',
nonlinear=.2,
show=False)
title="%s_%02d row: %.1f col: %.2f offset: %.2f''"
title=title % (expname,ccd,pos[0],pos[1],offset)
plt.title=title
plt.title_style['fontsize']=2
print >>stderr,' ',png_path
plt.write_img(1000,1000,png_path)
def _compare_psf_model(self, im, gm, mindex, i,fname,cenpix):
"""
Since we work in sky coords, can only generate the
diff image currently
"""
import os
import images
print fname
name='%s_%06d_%02d' % (self.psf_model,mindex,i)
imsum=im.sum()
model=gm.get_model()
model *= imsum/model.sum()
if 'em2' in self.psf_model:
gmix = gm.get_gmix()
gl=gmix.get_dlist()
offset=sqrt( (gl[0]['row']-gl[1]['row'])**2 +
(gl[0]['col']-gl[1]['col'])**2 )
print >>stderr,'offset:',offset
for g in gl:
print >>stderr,'gauss %d:' % (i+1),g['row'],g['col']
#diff = model-im
#resid = sqrt( (diff**2).sum() )/imsum
#title='%s sq resid: %s' % (name,resid)
#plt=images.view(diff, title=title,show=False)
bname=os.path.basename(fname)
bname=bname.replace('_psfcat.psf','')
title='%s row: %.1f col: %.2f' % (bname,cenpix[0],cenpix[1])
plt=images.compare_images(im, model,show=False,title=title)
plt.title_style['fontsize']=2
d=os.path.join(os.environ['HOME'], 'tmp','test-psf-rec')
if not os.path.exists(d):
os.makedirs(d)
pngname='%s_%s.png' % (bname,name)
path=os.path.join(d,pngname)
print >>stderr,' ',path
plt.write_img(1000,1000,path)
def _compare_gal(self):
"""
compare psf image to best fit model
"""
import images
res=self.res
gmix = res['fitter'].get_gmix()
psf_gmix = self._psf_gmix
gmix_conv = gmix.convolve(psf_gmix)
model_image = gmix_conv.make_image(self.gal_image.shape,
jacobian=res['jacob'])
plt=images.compare_images(self.gal_image,
model_image,
label1='galaxy',
label2=self._model,
show=False)
pname='gal-resid-%06d-%s.png' % (self.rindex,self._model)
print(" ",pname)
plt.write_img(1400,800,pname)
def _compare_gal(self, model, fitter):
"""
compare psf image to best fit model
"""
import images
gmix = fitter.get_gmix()
res=self.res
psf_gmix = res['psf_gmix']
gmix_conv = gmix.convolve(psf_gmix)
gal_image=self.gal_obs.image
model_image = gmix_conv.make_image(gal_image.shape,
jacobian=self.gal_obs.jacobian)
plt=images.compare_images(gal_image,
model_image,
label1='galaxy',
label2=model,
show=False)
pname='gal-resid-%06d-%s.png' % (self.index,model)
print(" ",pname)
plt.write_img(1400,800,pname)
def lucy_richardson_blind_deconvolution0_1(g, n, m, original):
#init h
print 'First error',images.compare_images(g, original)
plt.imsave(fname='l_r_blind/g.bmp', arr=np.uint8(images.make0to255(g)), cmap='gray')
#h1=conv.random_psf(3,3)
# h1[1,:3]=1/3.
##h=np.zeros(g.shape, dtype=float)
#h[255:258, 255:258]=h1
h = (1. / np.sum(g) ** 2) * conv.correlation2(g, g)
h/=np.sum(h)
#h=conv.random_psf(g.shape[0], g.shape[1])
#h/=np.sum(h)
#h = conv.correlation2(g, g)
# print np.sum(h)
#h/=np.sum(h)
plt.imsave(fname='l_r_blind/init_h.bmp', arr=np.uint8(images.make0to255(h)), cmap='gray')
print 'h sum=', np.sum(h)
#h[255:258, 255:258]=h1
f=np.copy(g)
print 'blind l-r'
print '0 %'
errors=[]
for i in range(n):
f_prev=np.copy(f)
#print 'h:'
#print '-- 0 %'
for k in range(m):
p = g / (conv.convolution2(f, h))
flr=np.fliplr(np.flipud(f))
h=conv.convolution2(p,flr)*h
h/=np.sum(f)
#h/=np.sum(h)
#h = (1. / np.sum(f)) * (h * conv.correlation2(f, p))
# p=g/(sg.convolve2d(f,h, mode='same'))
# h=(1./np.sum(f))*(h*sg.correlate2d(f,p,mode='same'))
#print '--', float(k+1) / m * 100, '%'
# f=(1./np.sum(h))*(f*sg.correlate2d(h,p,mode='same'))
# print 'f:'
# print '-- 0 %'
h /= np.sum(h)
for k in range(m):
p = g / (conv.convolution2(f, h))
hlr = np.fliplr(np.flipud(h))
f = conv.convolution2(p, hlr) * f
# f = (1. / np.sum(h)) * (f * conv.correlation2(h, p))
# p=g/(sg.convolve2d(f,h, mode='same'))
# print '--', float(k+1) / m * 100, '%'
#images.check_image(f)
print (float(i+1) / n) * 100, ' %'
name='l_r_blind/new_lena'+str(i)+'.bmp'
h_name='l_r_blind/h_'+str(i)+'.bmp'
plt.imsave(fname=name, arr=np.uint8(images.make0to255(f)), cmap='gray')
#print 't and f comp', images.compare_images(temp, f)
plt.imsave(fname=h_name, arr=np.uint8(images.make0to255(h)), cmap='gray')
images.check_image(images.correct_image(f))
error = images.compare_images(images.correct_image(f), original)
errors.append(error)
print 'err =',error
errors=np.array(errors)
plt.figure()
plt.plot(np.arange(errors.size), errors)
plt.xlabel('Steps')
plt.ylabel('Dif btw original and f_k')
plt.show()
return f,h
def main():
# Initialization - argument parsing, logging and stage preparations
logging.basicConfig(format='%(asctime)s %(message)s',
filename='logs.log',
level=logging.INFO)
logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))
args = parse_args()
out_folder = args.out_folder if args.out_folder.endswith(
'/') else args.out_folder + '/'
if not os.path.exists(out_folder):
os.makedirs(out_folder)
# Training
logging.info("Preparing images for training...")
_, gray_img, _, samples, labels = prepare_for_training(
args.training_image, kernels)
logging.info("Starting training process...")
weights = train(samples,
labels,
num_of_epochs=args.num_of_epochs,
batch_size=args.batch_size)
logging.info("Training done.")
# Training results
results = np.round(weights[-1, :], 2)
logging.info("Results: ")
for result, kernel, name in zip(results, kernels, kernel_names):
logging.info(f"Original {name} filter: \n{kernel}")
logging.info(f"Trained {name} filter: \n{result}")
out_image = out_folder + f"{name}/training_image_compare.jpg"
logging.info(f"Saving training comparition to {out_image}\n")
compare_images(convolution(gray_img, result),
convolution(gray_img, kernel),
out_image=out_image)
# Results on validation image
_, _, validation_image = load_normalize_and_grayscale(
args.validation_image)
logging.info(
f"Acceptance error is set to {args.acceptance_error}% of distance between highest and lowest possible value"
)
for result, kernel, name in zip(results, kernels, kernel_names):
out_image = out_folder + f"{name}/validation_image_compare.jpg"
logging.info(f"Saving validation comparition to {out_image}")
perc_of_similarity = compare_images(
convolution(validation_image, result),
convolution(validation_image, kernel),
out_image=out_image,
acceptance_error=args.acceptance_error)
logging.info(
f"Similarity between validation image filtered with trained and original {name} kernel is {perc_of_similarity}%"
)
# Animated matrix
if args.create_gifs:
for i, name in zip(range(weights.shape[1]), kernel_names):
out_image = out_folder + f"{name}/animated_training_matrix.gif"
logging.info(f"Creating matrix gif for {name}...")
create_matrix_gif(weights[:, i],
save_folder=out_folder + "gif_images/",
out_image=out_folder +
f"{name}/animated_training_matrix.gif")
else:
logging.info("Skipping gif creation.")
def compare_model(self):
import images
model = self.get_model()
dof = self.image.size - self.ngauss * 6
images.compare_images(self.image, model, label1="image", label2="model", skysig=sqrt(1 / self.ivar), dof=dof)
def compare_images(self, type, nrand=None):
"""
compare images of the specified type
parameters
----------
type: string
Type of images to compare, e.g. 'image','weight' etc.
nrand: integer, optional
Compare at most this many images. A random subset will be
drawn
"""
if nrand is not None:
nrand = min(nrand, self.ind1.size)
ids = self._get_random_subset(nrand)
else:
ids = numpy.arange(self.ind1.size)
means = []
ntot = ids.size
for icount, index in enumerate(ids):
print(" %d/%d %d" % (icount + 1, ntot, index))
i1 = self.ind1[index]
i2 = self.ind2[index]
ncut = self._check_ncutout(i1, i2)
for icut in range(ncut):
im2 = self.m2.get_cutout(i2, icut, type=type)
im1 = self.m1.get_cutout(i1, icut, type=type)
#if type=='image':
# wt=self.m2.get_cutout(i2, icut, type='weight')
# err=numpy.sqrt(1.0/wt.max())
# print(" compare to noise:",err)
if type == 'image':
ok, mean, err, std = self._compare_images(im1, im2)
means.append(mean)
elif type == 'weight':
self._compare_weights(im1, im2)
else:
self._compare_images_exact(im1, im2)
if type == 'image' and self.png_prefix is not None:
import images
fname = self.png_prefix + '-imdiff-%06d-%03d.png' % (index,
icut)
print("writing:", fname)
if ok:
oks = 'OK'
else:
oks = 'Not OK'
images.compare_images(
im1,
im2,
dims=(1500, 1500),
#width=1500,
#height=1500,
title='rms: %.3g mean: %.3g +/- %.3g %s' %
(std, mean, err, oks),
file=fname,
)
#if 'q'==raw_input("hit a key: (q to quit)"):
# stop
if type == 'image':
import esutil as eu
print(len(means))
means = numpy.array(means)
mdiff = means.mean()
mdiff_err = means.std() / numpy.sqrt(means.size)
print("average mean diff: %g +/- %g" % (mdiff, mdiff_err))
mdiff, mdiff_std, mdiff_err = eu.stat.sigma_clip(means,
get_err=True)
print("clipped average mean diff: %g +/- %g" % (mdiff, mdiff_err))
if self.png_prefix is not None:
import biggles
binsize = mdiff_std * 0.1
fname = self.png_prefix + '-imdiff-means.png'
biggles.plot_hist(
means,
binsize=binsize,
visible=False,
file=fname,
)
def lucy_richardson_blind_deconvolution_pir(g, n, m,d, max_psf_size=0, init_h_mode='gaussian', original=None):
# g - blurred image
# m, n - count of interation in RL-method
# max_psf_size - How long must be PSF
# init_h_mode - How initialize PSF:
# 'gaussian' - gaussian PSF size = 3x3, sigma =
# 'horizontal' - motion blur size 3x3, ang=0
# 'vertical' - motion blir size 3x3 ang = 90
# 'wow' - init with g
plt.imsave(fname='l_r_blind/g.bmp', arr=np.uint8(g), cmap='gray')
if max_psf_size==0:
max_psf_size = min(g.shape[0], g.shape[1])
#
# init h:
#
if init_h_mode=='gaussian':
h = conv.gaussian(1,3,3)
elif init_h_mode == 'horizontal':
h = np.array([[0,0,0],
[1,1,1],
[0,0,0]], dtype=float)/3.
elif init_h_mode == 'vertical':
h =np.array([[0,1,0],
[0,1,0],
[0,1,0]], dtype=float)/3.
elif init_h_mode == 'wow':
mini_g=smisc.imresize(g, (3,3))
h = (1. / np.sum(mini_g) ** 2) * conv.correlation2(mini_g, mini_g)
h /= np.sum(h)
else:
h = conv.random_psf(3,3)
print h
s=3
err=[]
while (s<=max_psf_size):
print 'size =',s
mini_g=smisc.imresize(g, (s,s))
f = lucy_richardson_deconvolution(mini_g, h, 20000)
if (s!=3):
h=smisc.imresize(h, (s,s))
for k in range (d):
if(k!=0):
f = lucy_richardson_deconvolution(mini_g, h, 20000)
for i in range(n):
#f_prev = np.copy(f)
#Correct h
h_prev=np.copy(h)
for k in range(m):
p = mini_g / (conv.convolution2(f, h))
flr = np.fliplr(np.flipud(f))
h = conv.convolution2(p, flr)*h
#h /= np.sum(h)
#print 'h =',h
for k in range(m):
p = mini_g / (conv.convolution2(h_prev, f))
hlr = np.fliplr(np.flipud(h_prev))
f = conv.convolution2(p, hlr) * f
print (float(i + 1) / n) * 100, ' %'
name = 'l_r_blind/new_lena' +str(s)+'_'+ str(i) + '.bmp'
h_name = 'l_r_blind/h_'+str(s)+'_' + str(i) + '.bmp'
plt.imsave(fname=name, arr=np.uint8(images.correct_image(f)), cmap='gray')
plt.imsave(fname=h_name, arr=np.uint8(images.correct_image(h*255)), cmap='gray')
s=int(s*math.sqrt(2))
#
if(original!=None):
good_f = lucy_richardson_deconvolution(g, h, 20000)
print good_f.shape
dx = (good_f.shape[0]-original.shape[0])//2
dy = (good_f.shape[1]-original.shape[1])//2
err.append(images.compare_images(good_f[dx:original.shape[0]+dx,
dy:original.shape[1] + dy],
original))
err=np.array(err)
plt.figure()
plt.plot(np.arange(err.size), err)
#plt.imshow(h,cmap='gray')
plt.show()
f = lucy_richardson_deconvolution(g, h, 5000)
return f, h
def test():
import images
import fitsio
import os
#import mchuff
dir='./mcal-tests'
if not os.path.exists(dir):
os.makedirs(dir)
step=0.01
shears=[Shape(step,0.0), Shape(0.0,step)]
for i,shear in enumerate(shears):
for type in ['gal','psf']:
obs, obs_sheared_dilated = _get_sim_obs(shear.g1,shear.g2,
r50=2.0, r50_psf=1.5)
m=Metacal(obs)
if type=='gal':
obs_mcal = m.get_obs_galshear(shear)
else:
obs_mcal = m.get_obs_psfshear(shear)
'''
s, us, tpsf = mchuff.metaCalibrate(galsim.Image(obs.image, scale=1.0),
galsim.Image(obs.psf.image,scale=1.0),
g1=shear.g1, g2=shear.g2,
gal_shear=type=='gal')
print("psf:",numpy.abs(tpsf.array - obs_mcal.psf.image).max()/obs_mcal.psf.image.max())
print("im:",numpy.abs(s.array - obs_mcal.image).max()/obs_mcal.image.max())
'''
images.compare_images(obs_sheared_dilated.image,
obs_mcal.image,
label1='shear/dilate',
label2='metacal',
width=1000,
height=1000)
if i==0 and type=='gal':
imfile='test-image.fits'
imfile=os.path.join(dir, imfile)
print("writing image:",imfile)
fitsio.write(imfile, obs.image, clobber=True)
psffile='test-psf.fits'
psffile=os.path.join(dir, psffile)
print("writing psf:",psffile)
fitsio.write(psffile, obs.psf.image, clobber=True)
mcalfile='test-image-mcal-%sshear-%.2f-%.2f.fits' % (type,shear.g1,shear.g2)
mcalfile=os.path.join(dir,mcalfile)
print("writing metacaled imag:",mcalfile)
fitsio.write(mcalfile, obs_mcal.image, clobber=True)
mcal_psf_file='test-psf-mcal-%sshear-%.2f-%.2f.fits' % (type,shear.g1,shear.g2)
mcal_psf_file=os.path.join(dir,mcal_psf_file)
print("writing metacaled psf image:",mcal_psf_file)
fitsio.write(mcal_psf_file, obs_mcal.psf.image, clobber=True)
readme=os.path.join(dir, 'README')
with open(readme,'w') as fobj:
fobj.write("""metacal test files
original images:
----------------
test-image.fits
test-psf.fits
metacaled images:
-----------------
# galaxy sheared
test-image-mcal-galshear-0.01-0.00.fits
test-psf-mcal-galshear-0.01-0.00.fits
test-image-mcal-galshear-0.00-0.01.fits
test-psf-mcal-galshear-0.00-0.01.fits
# psf sheared
test-image-mcal-psfshear-0.01-0.00.fits
test-psf-mcal-psfshear-0.01-0.00.fits
test-image-mcal-psfshear-0.00-0.01.fits
test-psf-mcal-psfshear-0.00-0.01.fits
""" )
def do_meta_mof_full_withsim(sim, fit_conf, fitter, show=False):
"""
not finding groups, just fitting everything. This means
it won't work on bigger images with lots of empty space
"""
import galsim
import mof
assert fit_conf['fofs']['find_fofs'] == False
tm0 = time.time()
mofc = fit_conf['mof']
# create metacal versions of image
metacal_pars = fit_conf['metacal']['metacal_pars']
if metacal_pars.get('symmetrize_psf', False):
fitters._fit_all_psfs([sim.obs], fit_conf['mof']['psf'])
# create the catalog based on original images
# this will just run sx and create seg and
# cat
medser = sim.get_medsifier()
if medser.cat.size == 0:
return {}, 0, 0.0
cat = medser.cat
mof_fitter, data = fitter.go(
sim.obs,
cat,
ntry=mofc['ntry'],
get_fitter=True,
)
tobs = sim.obs[0][0]
if show:
gmix = mof_fitter.get_convolved_gmix()
_plot_compare_model(gmix, tobs)
sim_mbobs_1p = ngmix.MultiBandObsList()
sim_mbobs_1m = ngmix.MultiBandObsList()
for band, obslist in enumerate(sim.obs):
sim_obslist_1p = ngmix.ObsList()
sim_obslist_1m = ngmix.ObsList()
band_gmix0 = mof_fitter.get_gmix(band=band, )
theta = fitter.rng.uniform(low=0.0, high=np.pi)
#gmix0 = gmix0.get_rotated(theta)
for obsnum, obs in enumerate(obslist):
jac = obs.jacobian
scale = jac.scale
gmix0 = band_gmix0.copy()
gmix0.set_flux(gmix0.get_flux() / scale**2)
# cheating on psf for now
ny, nx = obs.image.shape
# galsim does everything relative to the canonical center, but
# for the mof fitter we had the origin a 0,0. Shift over by
# the cen
ccen = (np.array(obs.image.shape) - 1.0) / 2.0
gs0 = gmix0.make_galsim_object()
gs0 = gs0.shift(dx=-ccen[1] * scale, dy=-ccen[1] * scale)
if show and obsnum == 0:
import images
#gs = gmix0.make_galsim_object(psf=sim.psf)
#gs = gs.shift(dx=-ccen[1]*scale, dy=-ccen[1]*scale)
gs = galsim.Convolve(gs0, sim.psf)
tim = gs.drawImage(nx=nx, ny=ny,
scale=sim['pixel_scale']).array
images.compare_images(sim.obs[0][0].image, tim)
if 'q' == input('hit a key (q to quit): '):
stop
gs0_1p = gs0.shear(g1=0.01, g2=0.0)
gs0_1m = gs0.shear(g1=-0.01, g2=0.0)
gs_1p = galsim.Convolve(gs0_1p, sim.psf)
gs_1m = galsim.Convolve(gs0_1m, sim.psf)
im_1p = gs_1p.drawImage(nx=nx, ny=ny,
scale=sim['pixel_scale']).array
im_1m = gs_1m.drawImage(nx=nx, ny=ny,
scale=sim['pixel_scale']).array
# adding same noise to both
noise_image = ngmix.simobs.get_noise_image(obs.weight,
rng=fitter.rng)
im_1p += noise_image
im_1m += noise_image
# this one will be used for fixnoise
noise_image2 = ngmix.simobs.get_noise_image(obs.weight,
rng=fitter.rng)
sobs_1p = ngmix.Observation(
im_1p,
weight=obs.weight.copy(),
jacobian=jac,
psf=obs.psf.copy(),
noise=noise_image2.copy(),
)
sobs_1m = ngmix.Observation(
im_1m,
weight=obs.weight.copy(),
jacobian=jac,
psf=obs.psf.copy(),
noise=noise_image2.copy(),
)
sim_obslist_1p.append(sobs_1p)
sim_obslist_1m.append(sobs_1m)
sim_mbobs_1p.append(sim_obslist_1p)
sim_mbobs_1m.append(sim_obslist_1m)
# for the measurement on real data
odict = ngmix.metacal.get_all_metacal(sim.obs,
rng=fitter.rng,
**metacal_pars)
sim_metacal_pars = {}
sim_metacal_pars.update(metacal_pars)
sim_metacal_pars['use_noise_image'] = True
sim_odict_1p = ngmix.metacal.get_all_metacal(
sim_mbobs_1p,
rng=fitter.rng, # not needed
**sim_metacal_pars)
sim_odict_1m = ngmix.metacal.get_all_metacal(
sim_mbobs_1m,
rng=fitter.rng, # not needed
**sim_metacal_pars)
reslists = {}
reslists.update(_process_one_full_mof_metacal(mofc, odict, cat, fitter))
reslists.update(
_process_one_full_mof_metacal(mofc,
sim_odict_1p,
cat,
fitter,
prefix='sim1p'))
reslists.update(
_process_one_full_mof_metacal(mofc,
sim_odict_1m,
cat,
fitter,
prefix='sim1m'))
nobj = cat.size
tm_fit = time.time() - tm0
return reslists, nobj, tm_fit
def test():
import images
import fitsio
import os
#import mchuff
dir = './mcal-tests'
if not os.path.exists(dir):
os.makedirs(dir)
step = 0.01
shears = [Shape(step, 0.0), Shape(0.0, step)]
for i, shear in enumerate(shears):
for type in ['gal', 'psf']:
obs, obs_sheared_dilated = _get_sim_obs(shear.g1,
shear.g2,
r50=2.0,
r50_psf=1.5)
m = Metacal(obs)
if type == 'gal':
obs_mcal = m.get_obs_galshear(shear)
else:
obs_mcal = m.get_obs_psfshear(shear)
images.compare_images(obs_sheared_dilated.image,
obs_mcal.image,
label1='shear/dilate',
label2='metacal',
width=1000,
height=1000)
if i == 0 and type == 'gal':
imfile = 'test-image.fits'
imfile = os.path.join(dir, imfile)
print("writing image:", imfile)
fitsio.write(imfile, obs.image, clobber=True)
psffile = 'test-psf.fits'
psffile = os.path.join(dir, psffile)
print("writing psf:", psffile)
fitsio.write(psffile, obs.psf.image, clobber=True)
mcalfile = 'test-image-mcal-%sshear-%.2f-%.2f.fits' % (
type, shear.g1, shear.g2)
mcalfile = os.path.join(dir, mcalfile)
print("writing metacaled imag:", mcalfile)
fitsio.write(mcalfile, obs_mcal.image, clobber=True)
mcal_psf_file = 'test-psf-mcal-%sshear-%.2f-%.2f.fits' % (
type, shear.g1, shear.g2)
mcal_psf_file = os.path.join(dir, mcal_psf_file)
print("writing metacaled psf image:", mcal_psf_file)
fitsio.write(mcal_psf_file, obs_mcal.psf.image, clobber=True)
readme = os.path.join(dir, 'README')
with open(readme, 'w') as fobj:
fobj.write("""metacal test files
original images:
----------------
test-image.fits
test-psf.fits
metacaled images:
-----------------
# galaxy sheared
test-image-mcal-galshear-0.01-0.00.fits
test-psf-mcal-galshear-0.01-0.00.fits
test-image-mcal-galshear-0.00-0.01.fits
test-psf-mcal-galshear-0.00-0.01.fits
# psf sheared
test-image-mcal-psfshear-0.01-0.00.fits
test-psf-mcal-psfshear-0.01-0.00.fits
test-image-mcal-psfshear-0.00-0.01.fits
test-psf-mcal-psfshear-0.00-0.01.fits
""")
def test_2gauss(counts=100.0, noise=0.0, maxiter=100,show=False):
import time
dims=[25,25]
cen=(numpy.array(dims)-1.0)/2.0
jacob=UnitJacobian(row=cen[0], col=cen[1])
cen1=[ -3.25, -3.25]
cen2=[ 3.0, 0.5]
e1_1=0.1
e2_1=0.05
T_1=8.0
counts_1=0.4*counts
irr_1 = T_1/2.*(1-e1_1)
irc_1 = T_1/2.*e2_1
icc_1 = T_1/2.*(1+e1_1)
e1_2=-0.2
e2_2=-0.1
T_2=4.0
counts_2=0.6*counts
irr_2 = T_2/2.*(1-e1_2)
irc_2 = T_2/2.*e2_2
icc_2 = T_2/2.*(1+e1_2)
pars = [counts_1, cen1[0],cen1[1], irr_1, irc_1, icc_1,
counts_2, cen2[0],cen2[1], irr_2, irc_2, icc_2]
gm=gmix.GMix(pars=pars)
print('gmix true:')
print(gm)
im0=gm.make_image(dims, jacobian=jacob)
im = im0 + noise*numpy.random.randn(im0.size).reshape(dims)
imsky,sky = prep_image(im)
obs=Observation(imsky, jacobian=jacob)
gm_guess=gm.copy()
gm_guess._data['p']=[0.5,0.5]
gm_guess._data['row'] += 4*srandu(2)
gm_guess._data['col'] += 4*srandu(2)
gm_guess._data['irr'] += 0.5*srandu(2)
gm_guess._data['irc'] += 0.5*srandu(2)
gm_guess._data['icc'] += 0.5*srandu(2)
print('guess:')
print(gm_guess)
for i in xrange(2):
tm0=time.time()
em=GMixEM(obs)
em.go(gm_guess, sky, maxiter=maxiter)
tm=time.time()-tm0
print('time:',tm,'seconds')
gmfit=em.get_gmix()
res=em.get_result()
print('best fit:')
print(gmfit)
print('results')
print(res)
if show:
import images
imfit=gmfit.make_image(im.shape)
imfit *= (im0.sum()/imfit.sum())
images.compare_images(im, imfit)
return tm
def test_1gauss_jacob(counts_sky=100.0,
noise_sky=0.0,
maxiter=100,
show=False):
import time
#import images
dims=[25,25]
cen=[dims[0]/2., dims[1]/2.]
#j1,j2,j3,j4=0.26,0.02,-0.03,0.23
dvdrow,dvdcol,dudrow,dudcol=-0.04,-0.915,1.10,0.12
j=Jacobian(row=cen[0],
col=cen[1],
dvdrow=dvdrow,
dvdcol=dvdcol,
dudrow=dudrow,
dudcol=dudcol)
jfac=j.get_scale()
g1=0.1
g2=0.05
Tsky=8.0*jfac**2
noise_pix=noise_sky/jfac**2
pars = [0.0, 0.0, g1, g2, Tsky, counts_sky]
gm=gmix.GMixModel(pars, "gauss")
print('gmix true:')
print(gm)
im0=gm.make_image(dims, jacobian=j)
im = im0 + noise_pix*numpy.random.randn(im0.size).reshape(dims)
imsky,sky = prep_image(im)
obs=Observation(imsky, jacobian=j)
gm_guess=gm.copy()
gm_guess._data['p']=1.0
gm_guess._data['row'] += srandu()
gm_guess._data['col'] += srandu()
gm_guess._data['irr'] += srandu()
gm_guess._data['irc'] += srandu()
gm_guess._data['icc'] += srandu()
print('guess:')
print(gm_guess)
tm0=time.time()
em=GMixEM(obs)
em.go(gm_guess, sky, maxiter=maxiter)
tm=time.time()-tm0
print('time:',tm,'seconds')
gmfit=em.get_gmix()
res=em.get_result()
print('best fit:')
print(gmfit)
print('results')
print(res)
if show:
import images
imfit=gmfit.make_image(im.shape, jacobian=j)
imfit *= (im0.sum()/imfit.sum())
images.compare_images(im, imfit)
return gmfit
def test_1gauss(counts=1.0,
noise=0.0,
T=4.0,
maxiter=4000,
g1=0.0,
g2=0.0,
show=False,
pad=False,
verbose=True,
seed=31415):
import time
rng=numpy.random.RandomState(seed)
sigma=numpy.sqrt(T/2)
dim=int(2*5*sigma)
dims=[dim]*2
cen=[dims[0]/2., dims[1]/2.]
jacob=UnitJacobian(row=cen[0], col=cen[1])
pars = [0.0, 0.0, g1, g2, T, counts]
gm=gmix.GMixModel(pars, "gauss")
im0=gm.make_image(dims, jacobian=jacob)
im = im0 + rng.normal(size=im0.shape, scale=noise)
imsky,sky = prep_image(im)
obs=Observation(imsky, jacobian=jacob)
guess_pars = [
srandu(rng=rng),
srandu(rng=rng),
0.05*srandu(rng=rng),
0.05*srandu(rng=rng),
T*(1.0 + 0.1*srandu(rng=rng)),
counts*(1.0 + 0.1*srandu(rng=rng)),
]
gm_guess= gmix.GMixModel(guess_pars, "gauss")
print("gm:",gm)
print("gm_guess:",gm_guess)
# twice, first time numba compiles the code
for i in xrange(2):
tm0=time.time()
em=GMixEM(obs)
em.go(gm_guess, sky, maxiter=maxiter)
tm=time.time()-tm0
gmfit=em.get_gmix()
res=em.get_result()
if verbose:
print("dims:",dims)
print("cen:",cen)
print('guess:')
print(gm_guess)
print('time:',tm,'seconds')
print()
print()
print('results')
print(res)
print()
print('gmix true:')
print(gm)
print('best fit:')
print(gmfit)
if show:
import images
imfit=gmfit.make_image(im.shape)
imfit *= (im0.sum()/imfit.sum())
images.compare_images(im, imfit)
return gmfit
def test_2gauss(counts=100.0, noise=0.0, maxiter=100,show=False):
import time
dims=[25,25]
cen=(numpy.array(dims)-1.0)/2.0
jacob=UnitJacobian(row=cen[0], col=cen[1])
cen1=[ -3.25, -3.25]
cen2=[ 3.0, 0.5]
e1_1=0.1
e2_1=0.05
T_1=8.0
counts_1=0.4*counts
irr_1 = T_1/2.*(1-e1_1)
irc_1 = T_1/2.*e2_1
icc_1 = T_1/2.*(1+e1_1)
e1_2=-0.2
e2_2=-0.1
T_2=4.0
counts_2=0.6*counts
irr_2 = T_2/2.*(1-e1_2)
irc_2 = T_2/2.*e2_2
icc_2 = T_2/2.*(1+e1_2)
pars = [counts_1, cen1[0],cen1[1], irr_1, irc_1, icc_1,
counts_2, cen2[0],cen2[1], irr_2, irc_2, icc_2]
gm=gmix.GMix(pars=pars)
print('gmix true:')
print(gm)
im0=gm.make_image(dims, jacobian=jacob)
im = im0 + noise*numpy.random.randn(im0.size).reshape(dims)
imsky,sky = prep_image(im)
obs=Observation(imsky, jacobian=jacob)
gm_guess=gm.copy()
gm_guess._data['p']=[0.5,0.5]
gm_guess._data['row'] += 4*srandu(2)
gm_guess._data['col'] += 4*srandu(2)
gm_guess._data['irr'] += 0.5*srandu(2)
gm_guess._data['irc'] += 0.5*srandu(2)
gm_guess._data['icc'] += 0.5*srandu(2)
print('guess:')
print(gm_guess)
for i in xrange(2):
tm0=time.time()
em=GMixEM(obs)
em.go(gm_guess, sky, maxiter=maxiter)
tm=time.time()-tm0
print('time:',tm,'seconds')
gmfit=em.get_gmix()
res=em.get_result()
print('best fit:')
print(gmfit)
print('results')
print(res)
if show:
import images
imfit=gmfit.make_image(im.shape)
imfit *= (im0.sum()/imfit.sum())
images.compare_images(im, imfit)
return tm
def test_1gauss_jacob(counts_sky=100.0,
noise_sky=0.0,
maxiter=100,
show=False):
import time
#import images
dims=[25,25]
cen=[dims[0]/2., dims[1]/2.]
#j1,j2,j3,j4=0.26,0.02,-0.03,0.23
dvdrow,dvdcol,dudrow,dudcol=-0.04,-0.915,1.10,0.12
j=Jacobian(row=cen[0],
col=cen[1],
dvdrow=dvdrow,
dvdcol=dvdcol,
dudrow=dudrow,
dudcol=dudcol)
jfac=j.get_scale()
g1=0.1
g2=0.05
Tsky=8.0*jfac**2
noise_pix=noise_sky/jfac**2
pars = [0.0, 0.0, g1, g2, Tsky, counts_sky]
gm=gmix.GMixModel(pars, "gauss")
print('gmix true:')
print(gm)
im0=gm.make_image(dims, jacobian=j)
im = im0 + noise_pix*numpy.random.randn(im0.size).reshape(dims)
imsky,sky = prep_image(im)
obs=Observation(imsky, jacobian=j)
gm_guess=gm.copy()
gm_guess._data['p']=1.0
gm_guess._data['row'] += srandu()
gm_guess._data['col'] += srandu()
gm_guess._data['irr'] += srandu()
gm_guess._data['irc'] += srandu()
gm_guess._data['icc'] += srandu()
print('guess:')
print(gm_guess)
tm0=time.time()
em=GMixEM(obs)
em.go(gm_guess, sky, maxiter=maxiter)
tm=time.time()-tm0
print('time:',tm,'seconds')
gmfit=em.get_gmix()
res=em.get_result()
print('best fit:')
print(gmfit)
print('results')
print(res)
if show:
import images
imfit=gmfit.make_image(im.shape, jacobian=j)
imfit *= (im0.sum()/imfit.sum())
images.compare_images(im, imfit)
return gmfit
def main():
args = get_args()
rng = np.random.RandomState(args.seed)
obs, obj_pars = make_data(rng=rng, noise=args.noise)
# fit the object to an exponential disk
prior = get_prior(rng=rng, scale=obs.jacobian.scale)
# fit using the levenberg marquards algorithm
fitter = ngmix.fitting.Fitter(model='exp', prior=prior)
# make parameter guesses based on a psf flux and a rough T
guesser = ngmix.guessers.TPSFFluxAndPriorGuesser(
rng=rng,
T=0.25,
prior=prior,
)
# psf fitting with coelliptical gaussians
psf_ngauss = 5
psf_fitter = ngmix.fitting.CoellipFitter(ngauss=psf_ngauss)
# special guesser for coelliptical gaussians
psf_guesser = ngmix.guessers.CoellipPSFGuesser(rng=rng, ngauss=psf_ngauss)
# this runs the fitter. We set ntry=2 to retry the fit if it fails
psf_runner = ngmix.runners.PSFRunner(
fitter=psf_fitter, guesser=psf_guesser,
ntry=2,
)
runner = ngmix.runners.Runner(
fitter=fitter, guesser=guesser,
ntry=2,
)
# this bootstraps the process, first fitting psfs then the object
boot = ngmix.bootstrap.Bootstrapper(
runner=runner,
psf_runner=psf_runner,
)
res = boot.go(obs)
print()
print('S/N:', res['s2n'])
print('true flux: %g meas flux: %g +/- %g (99.7%% conf)' % (
obj_pars['flux'], res['flux'], res['flux_err']*3,
))
print('true g1: %g meas g1: %g +/- %g (99.7%% conf)' % (
obj_pars['g1'], res['g'][0], res['g_err'][0]*3,
))
print('true g2: %g meas g2: %g +/- %g (99.7%% conf)' % (
obj_pars['g2'], res['g'][1], res['g_err'][1]*3,
))
if args.show:
try:
import images
except ImportError:
from espy import images
imfit = res.make_image()
images.compare_images(obs.image, imfit)
def test_1gauss(counts=1.0,
noise=0.0,
T=4.0,
maxiter=4000,
g1=0.0,
g2=0.0,
show=False,
pad=False,
verbose=True,
seed=31415):
import time
rng=numpy.random.RandomState(seed)
sigma=numpy.sqrt(T/2)
dim=int(2*5*sigma)
dims=[dim]*2
cen=[dims[0]/2., dims[1]/2.]
jacob=UnitJacobian(row=cen[0], col=cen[1])
pars = [0.0, 0.0, g1, g2, T, counts]
gm=gmix.GMixModel(pars, "gauss")
im0=gm.make_image(dims, jacobian=jacob)
im = im0 + rng.normal(size=im0.shape, scale=noise)
imsky,sky = prep_image(im)
obs=Observation(imsky, jacobian=jacob)
guess_pars = [
srandu(rng=rng),
srandu(rng=rng),
0.05*srandu(rng=rng),
0.05*srandu(rng=rng),
T*(1.0 + 0.1*srandu(rng=rng)),
counts*(1.0 + 0.1*srandu(rng=rng)),
]
gm_guess= gmix.GMixModel(guess_pars, "gauss")
print("gm:",gm)
print("gm_guess:",gm_guess)
# twice, first time numba compiles the code
for i in xrange(2):
tm0=time.time()
em=GMixEM(obs)
em.go(gm_guess, sky, maxiter=maxiter)
tm=time.time()-tm0
gmfit=em.get_gmix()
res=em.get_result()
if verbose:
print("dims:",dims)
print("cen:",cen)
print('guess:')
print(gm_guess)
print('time:',tm,'seconds')
print()
print()
print('results')
print(res)
print()
print('gmix true:')
print(gm)
print('best fit:')
print(gmfit)
if show:
import images
imfit=gmfit.make_image(im.shape)
imfit *= (im0.sum()/imfit.sum())
images.compare_images(im, imfit)
return gmfit
def test_1gauss(counts=1.0,
noise=0.0,
T=4.0,
maxiter=4000,
g1=0.0,
g2=0.0,
show=False,
pad=False,
verbose=True):
import time
sigma = numpy.sqrt(T / 2)
dim = int(2 * 5 * sigma)
dims = [dim] * 2
cen = [dims[0] / 2., dims[1] / 2.]
pars = [cen[0], cen[1], g1, g2, T, counts]
gm = gmix.GMixModel(pars, "gauss")
im0 = gm.make_image(dims)
im = im0 + noise * numpy.random.randn(im0.size).reshape(dims)
imsky, sky = prep_image(im)
obs = Observation(imsky)
gm_guess = gm.copy()
gm_guess._data['p'] = 1.0
gm_guess._data['row'] += 1 * srandu()
gm_guess._data['col'] += 1 * srandu()
gm_guess._data['irr'] += 0.5 * srandu()
gm_guess._data['irc'] += 0.5 * srandu()
gm_guess._data['icc'] += 0.5 * srandu()
tm0 = time.time()
em = GMixEM(obs)
em.run_em(gm_guess, sky, maxiter=maxiter)
tm = time.time() - tm0
gmfit = em.get_gmix()
res = em.get_result()
if verbose:
print("dims:", dims)
print("cen:", cen)
print('guess:')
print(gm_guess)
print('time:', tm, 'seconds')
print()
print()
print('results')
print(res)
print()
print('gmix true:')
print(gm)
print('best fit:')
print(gmfit)
if show:
import images
imfit = gmfit.make_image(im.shape)
imfit *= (im0.sum() / imfit.sum())
images.compare_images(im, imfit)
return gmfit
