def get_exp_guess(cen,cov,ngauss):
guess=[]
for i in xrange(ngauss):
g= {'p':1./ngauss,
'row':cen[0] + 0.1*(randu()-0.5),
'col':cen[1] + 0.1*(randu()-0.5),
'irr':cov[0] + 0.5*(randu()-0.5),
'irc':cov[1] + 0.5*(randu()-0.5),
'icc':cov[2] + 0.5*(randu()-0.5)}
guess.append(g)
return guess
def test_fit_2gauss_2psf(seed=45):
import images
from fimage import ellip2mom
print >>stderr,"seed:",seed
numpy.random.seed(seed)
Tpsf1 = 2.0
Tpsf2 = 4.0
epsf = 0.2
theta_psf = 80.0
cov_psf1 = ellip2mom(Tpsf1, e=epsf, theta=theta_psf)
cov_psf2 = ellip2mom(Tpsf2, e=epsf, theta=theta_psf)
psf=[{'p':0.7, 'irr':cov_psf1[0], 'irc':cov_psf1[1], 'icc':cov_psf1[2]},
{'p':0.3, 'irr':cov_psf2[0], 'irc':cov_psf2[1], 'icc':cov_psf2[2]}]
T1=3.0
T2=6.0
nsig=5
dim = int(nsig*T2)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
theta=23.7*numpy.pi/180.
eta=-0.7
ellip=(1+tanh(eta))/2
p1=0.4
p2=0.6
print >>stderr,'ellip:',ellip
pars=array([cen[0],cen[1],eta,theta,p1,p2,T1,T2])
print >>stderr,'pars'
gmix = gmix_fit.pars2gmix_coellip_pick(pars,ptype='eta')
im=gmix2image_em(gmix,dims, psf=psf)
p0=pars.copy()
p0[0] += 1*(randu()-0.5) # cen0
p0[1] += 1*(randu()-0.5) # cen1
p0[2] += 1*(randu()-0.5) # eta
p0[3] += 0.5*(randu()-0.5) # theta radians
p0[4] += 0.2*(randu()-0.5) # p1
p0[5] += 0.2*(randu()-0.5) # p2
p0[6] += 1*(randu()-0.5) # T1
p0[7] += 1*(randu()-0.5) # T2
print_pars(pars,front='pars: ')
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellip(im,
p0,
psf=psf,
ptype='eta',
verbose=True)
print 'numiter:',gf.numiter
print gf.popt
for i in xrange(len(pars)):
print '%10.6f %10.6f' % (pars[i],gf.popt[i])
def sample2d(self, n=None):
"""
Get samples in 2d g space
"""
if n is None:
is_scalar = True
n = 1
else:
is_scalar = False
samples1d = self.sample1d(n=n)
grand = samples1d[:, 0]
theta = randu(n) * 2 * numpy.pi
twotheta = 2 * theta
g1rand = grand * numpy.cos(twotheta)
g2rand = grand * numpy.sin(twotheta)
samples2d = zeros((n, self.ndim + 1))
samples2d[:, 0] = g1rand
samples2d[:, 1] = g2rand
samples2d[:, 2:] = samples1d[:, 1:]
if is_scalar:
samples2d = samples2d[0, :]
return samples2d
def sample2d(self, n=None):
"""
Get samples in 2d g space
"""
if n is None:
is_scalar=True
n=1
else:
is_scalar=False
samples1d = self.sample1d(n=n)
grand=samples1d[:,0]
theta = randu(n)*2*numpy.pi
twotheta = 2*theta
g1rand = grand*numpy.cos(twotheta)
g2rand = grand*numpy.sin(twotheta)
samples2d = zeros( (n, self.ndim+1) )
samples2d[:,0] = g1rand
samples2d[:,1] = g2rand
samples2d[:,2:] = samples1d[:,1:]
if is_scalar:
samples2d = samples2d[0,:]
return samples2d
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 _get_guesses(self, gal_cen, psf_cen):
cen_guess = gal_cen + self.guess_width_cen*srandu(2)
psf_cen_guess = psf_cen + self.guess_width_cen*srandu(2)
psf_irr_guess = self.guess_psf_irr*(1.0+0.01*srandu())
# guess gal bigger. Note random here is [0,1]
gal_irr_guess = self.guess_psf_irr*(1.0+1.0*randu())
return cen_guess, psf_cen_guess, psf_irr_guess, gal_irr_guess
def _get_guess_bdf(self,
widths=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01]):
"""
Get a guess centered on the truth
width is relative for T and counts
"""
nwalkers = self.conf['nwalkers']
res=self.res
gmix = res['em_gmix']
g1,g2,T = gmix.get_g1g2T()
flux = res['em_gauss_flux']
guess=numpy.zeros( (nwalkers, 7) )
# centers relative to jacobian center
guess[:,0] = widths[0]*srandu(nwalkers)
guess[:,1] = widths[1]*srandu(nwalkers)
guess_shape=get_shape_guess(g1, g2, nwalkers, width=widths[2])
guess[:,2]=guess_shape[:,0]
guess[:,3]=guess_shape[:,1]
guess[:,4] = get_positive_guess(T,nwalkers,width=widths[4])
counts_guess = get_positive_guess(flux,nwalkers,width=widths[5])
bfracs=numpy.zeros(nwalkers)
nhalf=nwalkers/2
bfracs[0:nhalf] = 0.01*randu(nhalf)
bfracs[nhalf:] = 0.99+0.01*randu(nhalf)
dfracs = 1.0 - bfracs
# bulge flux
guess[:,5] = bfracs*counts_guess
# disk flux
guess[:,6] = dfracs*counts_guess
return guess
def randomize_e1e2(e1start,e2start):
if e1start == 0 and e2start==0:
e1rand = 0.05*(randu()-0.5)
e2rand = 0.05*(randu()-0.5)
else:
nmax=100
ii=0
while True:
e1rand = e1start*(1 + 0.2*(randu()-0.5))
e2rand = e2start*(1 + 0.2*(randu()-0.5))
etot = sqrt(e1rand**2 + e2rand**2)
if etot < 0.95:
break
ii += 1
if ii==nmax:
wlog("---- hit max try on randomize e1e2, setting zero and restart")
e1start=0
e2start=0
ii=0
return e1rand, e2rand
def test_fit_1gauss_psf(seed=45):
from fimage import ellip2mom
import images
print >>stderr,"seed:",seed
numpy.random.seed(seed)
Tpsf = 2.0
epsf = 0.2
theta_psf = 80.0
cov_psf = ellip2mom(Tpsf, e=epsf, theta=theta_psf)
psf=[{'p':1.0,
'irr':cov_psf[0],
'irc':cov_psf[1],
'icc':cov_psf[2]}]
T=3.0
nsig=5
dim = int(nsig*T)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1.)/2.
theta=23.7*numpy.pi/180.
eta=-0.7
ellip=(1+tanh(eta))/2
print >>stderr,'ellip:',ellip
print >>stderr,'e1:',ellip*cos(2*theta)
print >>stderr,'e2:',ellip*sin(2*theta)
pars=array([cen[0],cen[1],eta,theta,1.,T])
print >>stderr,'pars'
gmix = gmix_fit.pars2gmix_coellip_pick(pars,ptype='eta')
im=gmix2image_em(gmix,dims,psf=psf)
#images.multiview(im)
p0=pars.copy()
p0[0] += 1*(randu()-0.5) # cen0
p0[1] += 1*(randu()-0.5) # cen1
p0[2] += 1*(randu()-0.5) # eta
#p0[3] += 1*(randu()-0.5) # theta radians
p0[3] += 0.5*(randu()-0.5) # theta radians
p0[4] += 0.2*(randu()-0.5) # p
p0[5] += 1*(randu()-0.5) # T
print_pars(pars,front='pars: ')
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellip(im, p0,
psf=psf,
ptype='eta',
verbose=True)
print 'numiter:',gf.numiter
print gf.popt
print gf.pcov
def get_f_p_vals_turb():
import fimage
from numpy.random import random as randu
from .gmix_fit import GMixFitCoellip
dims=[1000,1000]
fwhm=100.
im_nonoise=fimage.pixmodel.ogrid_turb_psf(dims, fwhm)
im,skysig=fimage.noise.add_noise_admom(im_nonoise, 1.e8)
#0.4422839982971848,0.9764735420431805,4.784430363572698
#0.5356908850142901,0.3829828442516049,0.08132627073410502
guess=array([100. + 0.01*(randu()-0.5),
100. + 0.01*(randu()-0.5),
0.01*(randu()-0.5),
0.01*(randu()-0.5),
fwhm + 0.01*(randu()-0.5),
0.2 + 0.01*(randu()-0.5),
0.08 + 0.01*(randu()-0.5),
0.08 + 0.01*(randu()-0.5),
0.4 + 0.01*(randu()-0.5),
0.54 + 0.01*(randu()-0.5)])
width=guess.copy()
width[:] = 100
gm = GMixFitCoellip(im, skysig,
guess,width,
Tpositive=True)
pars=gm.get_pars()
perr=gm.get_perr()
pars=pars.reshape(1,pars.size)
get_f_p_vals(pars=pars)
def test_fit_1gauss_fix(imove):
import images
numpy.random.seed(45)
T1=3.0
nsig=5
dim = int(nsig*T1)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1.)/2.
theta=23.7*numpy.pi/180.
eta=-0.7
ellip=(1+tanh(eta))/2
print >>stderr,'ellip:',ellip
print >>stderr,'e1:',ellip*cos(2*theta)
print >>stderr,'e2:',ellip*sin(2*theta)
pars=array([cen[0],cen[1],eta,theta,1.,T1])
print >>stderr,'pars'
gmix = gmix_fit.pars2gmix_coellip_pick(pars,ptype='eta')
im=gmix2image_em(gmix,dims)
#images.multiview(im)
p0=pars.copy()
if imove == 0:
p0[0] += 1*(randu()-0.5) # cen0
elif imove == 1:
p0[1] += 1*(randu()-0.5) # cen1
elif imove == 2:
p0[2] += 1*(randu()-0.5) # eta
elif imove == 3:
p0[3] += 1*(randu()-0.5) # theta radians
elif imove == 4:
p0[4] += 0.2*(randu()-0.5) # p
elif imove == 5:
p0[5] += 1*(randu()-0.5) # T
print_pars(pars,front='pars: ')
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellipFix(im, p0, imove, ptype='eta',
verbose=True)
print 'numiter:',gf.numiter
print gf.popt
print gf.pcov
def test_fit_1gauss_noisy(ellip=0.2, s2n=10000):
import images
import fimage
numpy.random.seed(35)
sigma = 1.4
T=2*sigma**2
nsig=5
dim = int(nsig*T)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1.)/2.
theta=23.7*numpy.pi/180.
#eta=-0.7
#ellip=(1+tanh(eta))/2
eta = ellip2eta(ellip+1.e-8)
print >>stderr,'ellip:',ellip
pars=array([cen[0],cen[1],eta,theta,1.,T])
print >>stderr,'pars'
gmix = gmix_fit.pars2gmix_coellip_pick(pars,ptype='eta')
nsub=1
im0=gmix2image_em(gmix,dims,nsub=nsub)
im,skysig = fimage.add_noise(im0, s2n,check=True)
images.multiview(im,title='nsub: %d' % nsub)
p0=pars.copy()
p0[0] += 1*(randu()-0.5) # cen0
p0[1] += 1*(randu()-0.5) # cen1
p0[2] += 0.2*(randu()-0.5) # eta
p0[3] += 0.5*(randu()-0.5) # theta radians
p0[4] += 0.1*(randu()-0.5) # p
p0[5] += 1*(randu()-0.5) # T
print_pars(pars,front='pars: ')
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellip(im, p0, ptype='eta',verbose=True)
print 'numiter:',gf.numiter
print_pars(gf.popt, front='popt: ')
print_pars(gf.perr, front='perr: ')
images.imprint(gf.pcov)
def testMax(self):
print('\n')
for noise in [0.001, 0.1, 1.0]:
print('=' * 10)
print('noise:', noise)
mdict = self.get_obs_data(noise)
obs = mdict['obs']
obs.set_psf(mdict['psf_obs'])
pars = mdict['pars'].copy()
pars[0] += randu(low=-0.1, high=0.1)
pars[1] += randu(low=-0.1, high=0.1)
pars[2] += randu(low=-0.1, high=0.1)
pars[3] += randu(low=-0.1, high=0.1)
pars[4] *= (1.0 + randu(low=-0.1, high=0.1))
pars[5] *= (1.0 + randu(low=-0.1, high=0.1))
max_pars = {'method': 'lm', 'lm_pars': {'maxfev': 4000}}
prior = joint_prior.make_uniform_simple_sep(
[0.0, 0.0], # cen
[0.1, 0.1], # g
[-10.0, 3500.], # T
[-0.97, 1.0e9]) # flux
boot = Bootstrapper(obs)
boot.fit_psfs('gauss', 4.0)
boot.fit_max('exp', max_pars, pars, prior=prior)
res = boot.get_max_fitter().get_result()
print_pars(mdict['pars'], front='pars true: ')
print_pars(res['pars'], front='pars meas: ')
print_pars(res['pars_err'], front='pars err: ')
print('s2n:', res['s2n_w'])
def get_prior_turb(self, trial):
ngauss=trial['ngauss']
eguess=trial['eguess']
uniform_p=trial['uniform_p']
randomize=trial['randomize']
if ngauss != 3:
raise ValueError("ngauss==3 only for now")
npars=2*ngauss+4
prior=zeros(npars)
width=zeros(npars)
prior[0] = self.amres['row']
prior[1] = self.amres['col']
width[0] = 1000
width[1] = 1000
if eguess is not None:
prior[2],prior[3] = eguess
else:
prior[2] = self.amres['e1']
prior[3] = self.amres['e2']
T = self.amres['Irr'] + self.amres['Icc']
# turbulent psf guess
Tmax = T*8.3
Tfrac1 = 1.7/8.3
Tfrac2 = 0.8/8.3
prior[4] = Tmax
prior[5] = Tfrac1
prior[6] = Tfrac2
if uniform_p:
wlog(" uniform p")
prior[7] = self['counts']/ngauss
prior[8] = self['counts']/ngauss
prior[9] = self['counts']/ngauss
else:
prior[7] = self['counts']*0.08
prior[8] = self['counts']*0.38
prior[9] = self['counts']*0.53
# uninformative priors
width[2] = 1000
width[3] = 1000
width[4] = 1000
width[5:] = 1000
if randomize:
wlog(" randomizing")
e1start=prior[2]
e2start=prior[3]
prior[2],prior[3] = randomize_e1e2(e1start,e2start)
prior[4] += prior[4]*0.05*(randu()-0.5)
prior[5] += prior[5]*0.05*(randu()-0.5)
prior[6] += prior[6]*0.05*(randu()-0.5)
prior[7] += prior[7]*0.05*(randu()-0.5)
prior[8] += prior[8]*0.05*(randu()-0.5)
prior[9] += prior[9]*0.05*(randu()-0.5)
return prior, width
def get_prior_2generic(self, trial):
"""
generic guesses
"""
wlog("using generic guesses")
ngauss=trial['ngauss']
eguess=trial['eguess']
uniform_p=trial['uniform_p']
randomize=trial['randomize']
if ngauss != 2:
raise ValueError("ngauss==2 only for now")
npars=2*ngauss+4
prior=zeros(npars)
width=zeros(npars) + 1.e20
prior[0] = self.amres['row']
prior[1] = self.amres['col']
if eguess is not None:
prior[2],prior[3] = eguess
else:
prior[2] = self.amres['e1']
prior[3] = self.amres['e2']
T = self.amres['Irr'] + self.amres['Icc']
Tmax = T*3
T1 = T*0.5
Tfrac1 = T1/Tmax
prior[4] = Tmax
prior[5] = Tfrac1
if uniform_p:
wlog(" uniform p")
prior[6] = self['counts']/ngauss
prior[7] = self['counts']/ngauss
else:
prior[6] = self['counts']*0.2
prior[7] = self['counts']*0.8
if randomize:
wlog(" randomizing")
e1start=prior[2]
e2start=prior[3]
prior[2],prior[3] = randomize_e1e2(e1start,e2start)
prior[4] += prior[4]*0.05*(randu()-0.5)
prior[5] += prior[5]*0.05*(randu()-0.5)
prior[6] += prior[6]*0.05*(randu()-0.5)
prior[7] += prior[7]*0.05*(randu()-0.5)
pvals = prior[ [6,7] ].copy()
pvals *= self['counts']/pvals.sum()
prior[6] = pvals[0]
prior[7] = pvals[1]
return prior, width
def get_prior_2psfield(self, trial):
"""
Take two of the guesses from the psfield sigma1,sigma2
"""
ngauss=trial['ngauss']
eguess=trial['eguess']
uniform_p=trial['uniform_p']
randomize=trial['randomize']
if ngauss != 2:
raise ValueError("ngauss==2 only for now")
npars=2*ngauss+4
prior=zeros(npars)
width=zeros(npars) + 1.e20
prior[0] = self.amres['row']
prior[1] = self.amres['col']
if eguess is not None:
prior[2],prior[3] = eguess
else:
prior[2] = self.amres['e1']
prior[3] = self.amres['e2']
T = self.amres['Irr'] + self.amres['Icc']
c = self['filternum']
T1 = 2*self.psfield['psf_sigma1'][0,c]**2
T2 = 2*self.psfield['psf_sigma2'][0,c]**2
Tmax = T2
Tfrac1 = T1/T2
prior[4] = Tmax
prior[5] = Tfrac1
if uniform_p:
wlog(" uniform p")
prior[6] = self['counts']/ngauss
prior[7] = self['counts']/ngauss
else:
# psf_b is p2/p1
pvals = array([self.psfield['psf_b'][0,c], 1.])
pvals /= self['counts']*pvals.sum()
prior[6] = pvals[0]
prior[7] = pvals[1]
if randomize:
wlog(" randomizing")
e1start=prior[2]
e2start=prior[3]
prior[2],prior[3] = randomize_e1e2(e1start,e2start)
prior[4] += prior[4]*0.05*(randu()-0.5)
prior[5] += prior[5]*0.05*(randu()-0.5)
prior[6] += prior[6]*0.05*(randu()-0.5)
prior[7] += prior[7]*0.05*(randu()-0.5)
pvals = prior[ [6,7] ].copy()
pvals *= self['counts']/pvals.sum()
prior[6] = pvals[0]
prior[7] = pvals[1]
return prior, width
def get_prior_test(self, trial):
import images
eguess=trial['eguess']
randomize=trial['randomize']
uniform_p=trial['uniform_p']
# good answer from gmix
dguess=[{'p':0.58,'row':15.,'col':15.,'irr':1.3,'irc':-0.05,'icc':1.16},
{'p':0.19,'row':15.,'col':15.,'irr':7.7,'irc':-0.23,'icc':6.8}]
#psf = gmix_image.gmix2image(dguess,self.psf.shape)
#psf += self['skysig']*numpy.random.random(self.psf.size).reshape(self.psf.shape)
#psf *= self['counts']/psf.sum()
#self.psf=psf
#stop
e1 = (dguess[0]['icc']-dguess[0]['irr'])/(dguess[0]['icc']+dguess[0]['irr'])
e2 = 2.*dguess[0]['irc']/(dguess[0]['icc']+dguess[0]['irr'])
Tmax = dguess[1]['icc'] + dguess[1]['irr']
Tfrac1 = (dguess[0]['icc'] + dguess[0]['irr'])/Tmax
pvals = array([d['p'] for d in dguess])
#pvals *= self['counts']/pvals.sum()
ngauss=len(dguess)
npars = ngauss*2+4
prior=zeros(npars)
width=zeros(npars) + 1.e20
prior[0] = dguess[0]['row']
prior[1] = dguess[0]['col']
if eguess:
prior[2],prior[3] = eguess
else:
prior[2] = e1
prior[3] = e2
prior[4] = Tmax
prior[5] = Tfrac1
if uniform_p:
prior[6] = self['counts']/ngauss
prior[7] = self['counts']/ngauss
else:
prior[6] = pvals[1]
prior[7] = pvals[0]
if randomize:
e1start,e2start = prior[2],prior[3]
prior[2],prior[3] = randomize_e1e2(e1start,e2start)
prior[4] += prior[4]*0.05*(randu()-0.5)
prior[5] += prior[5]*0.05*(randu()-0.5)
prior[6] += prior[6]*0.05*(randu()-0.5)
prior[7] += prior[7]*0.05*(randu()-0.5)
#pvals = prior[ [6,7] ].copy()
#pvals *= self['counts']/pvals.sum()
#prior[6] = pvals[0]
#prior[7] = pvals[1]
"""
width[0] = 0.001
width[1] = 0.001
width[2] = 0.001
width[3] = 0.001
width[4] = 0.001
width[5] = 0.001
width[6] = 0.001
width[7] = 0.001
width[:] = 1.e-7
"""
return prior, width
def get_random_plot(name, direc):
"""
Random plot generation method.
Inputs:
name: (string) name of the plot which will be saved.
Outputs:
ax : (matplotlib obj) Matplotlib object of the axes of the plot
fig : (matplotlib obj) Matplotlib object of the figure of the plot
x, y : (list, list) Actuall x and y coordinates of the points.
s : (list) sizes of the points.
categories : (list) categories of the points.
tick_size : (list) Tick size on the plot. [width, length]
axes_x_pos, axes_y_pos: (float, float) Position of the labels of the axis.
"""
# PLOT STYLE
style = random.choice(styles)
plt.style.use(style)
# POINT DISTRIBUTION
distribution = random.choice(point_dist)
# RESOLUTION AND TICK SIZE
dpi = int(dpi_min + randu(1)[0]*(dpi_max-dpi_min))
figsize = (figsize_min+randu(2)*(figsize_max-figsize_min)).astype(int)
tick_size = [(tick_size_width_min+randu(1)[0]*(tick_size_width_max-tick_size_width_min)),
(tick_size_length_min+randu(1)[0]*(tick_size_length_max-tick_size_length_min))]
tick_size.sort()
fig, ax = plt.subplots(figsize=figsize, dpi=dpi)
# ACTUAL POINTS
points_nb = int(points_nb_min + (randu(1)[0]**1.5)*(points_nb_max-points_nb_min))
x_scale = int(x_min_top+randu(1)[0]*(x_max_top - x_min_top))
y_scale = int(y_min_top+randu(1)[0]*(y_max_top - y_min_top))
x_scale_range = x_scale + int(randu(1)[0]*x_scale_range_max)
y_scale_range = y_scale + int(randu(1)[0]*y_scale_range_max)
x_min = (-randu(1)[0]+randu(1)[0])*10**(x_scale)
x_max = (-randu(1)[0]+randu(1)[0])*10**(x_scale_range)
x_min, x_max = min(x_min,x_max), max(x_min,x_max)
y_min = (-randu(1)[0]+randu(1)[0])*10**(y_scale)
y_max = (-randu(1)[0]+randu(1)[0])*10**(y_scale_range)
y_min, y_max = min(y_min,y_max), max(y_min,y_max)
if distribution=='uniform':
x = x_min+randu(points_nb)*(x_max-x_min)
y = y_min+randu(points_nb)*(y_max-y_min)
elif distribution=='linear':
x = x_min+randu(points_nb)*(x_max-x_min)
y = x*(max(y_max,-y_min)/(max(x_max,-x_min)))*random.choice([-1.0,1.0]) + (y_min+randu(points_nb)*(y_max-y_min))*randu(1)[0]/2.0
elif distribution=='quadratic':
x = x_min+randu(points_nb)*(x_max-x_min)
y = x**2*(1.0/(max(x_max,-x_min)))**2*max(y_max,-y_min)*random.choice([-1.0,1.0]) + (y_min+randu(points_nb)*(y_max-y_min))*randu(1)[0]/2.0
# POINTS VARIATION
nb_points_var = 1+int(randu(1)[0]*max_points_variations)
nb_points_var_colors = 1+int(randu(1)[0]*nb_points_var)
nb_points_var_markers = 1+int(randu(1)[0]*(nb_points_var-nb_points_var_colors))
nb_points_var_size = max(1,1+nb_points_var-nb_points_var_colors-nb_points_var_markers)
rand_color_number = randu(1)[0]
if rand_color_number<=0.5:
colors = cm.rainbow(randu(nb_points_var_colors))
elif rand_color_number>0.5 and rand_color_number<=0.7:
colors = cm.gnuplot(randu(nb_points_var_colors))
elif rand_color_number>0.7 and rand_color_number<=0.8:
colors = cm.copper(randu(nb_points_var_colors))
else:
colors = cm.gray(np.linspace(0,0.6,nb_points_var_colors))
s_set = (size_points_min+randu(nb_points_var_size)*(size_points_max-size_points_min))**2
markers_subset = list(np.random.choice(markers,size=nb_points_var_markers))
markers_empty = randu(1)[0]>0.75
markers_empty_ratio = random.choice([0.0,0.5,0.7])
# BUILDING THE PLOT
s = []
categories = []
cat_dict = {}
index_cat = 0
for _x, _y, in zip(x,y):
s_ = random.choice(s_set)
c_ = random.choice(colors)
m_ = random.choice(markers_subset)
if m_ in markers_with_full and markers_empty:
e_ = randu(1)[0]> markers_empty_ratio
else:
e_ = False
cat = [s_,c_,m_, e_]
if cat_in_dict(cat,cat_dict) is False:
cat_dict[index_cat] = cat
index_cat += 1
categories.append(cat_in_dict(cat,cat_dict))
s.append(s_)
if e_:
plt.scatter(_x, _y, s=s_, color = c_, marker=m_, facecolors='none')
else:
plt.scatter(_x, _y, s=s_, color = c_, marker=m_)
# PAD BETWEEN TICKS AND LABELS
pad_x = max(tick_size[1]+0.5,int(pad_min + randu(1)[0]*(pad_max-pad_min)))
pad_y = max(tick_size[1]+0.5,int(pad_min + randu(1)[0]*(pad_max-pad_min)))
direction_ticks_x = random.choice(direction_ticks)
direction_ticks_y = random.choice(direction_ticks)
# NON-DEFAULT TICKS PROB, WITH THRESHOLD OF 0.6
weid_ticks_prob = randu(1)[0]
# TICKS STYLE AND LOCATION (X AXIS)
if randu(1)[0]>0.5:
axes_x_pos = 1
ax.xaxis.tick_top()
ax.xaxis.set_label_position("top")
if weid_ticks_prob >0.6:
ax.xaxis.set_tick_params(width=tick_size[0], length=tick_size[1], color='black', pad=pad_x,
direction= direction_ticks_x, bottom=randu(1)[0]>0.5, top=True)
else:
ax.xaxis.set_tick_params(bottom=randu(1)[0]>0.5, top=True)
if randu(1)[0]>0.5:
ax.spines['bottom'].set_visible(False)
ax.xaxis.set_tick_params(bottom=False)
if randu(1)[0]>0.5:
axes_x_pos = randu(1)[0]
ax.spines['top'].set_position(('axes',axes_x_pos ))
else:
axes_x_pos = 0
if weid_ticks_prob >0.6:
ax.xaxis.set_tick_params(width=tick_size[0], length=tick_size[1], color='black', pad=pad_x,
direction= direction_ticks_x, bottom=True, top=randu(1)[0]>0.5)
else:
ax.xaxis.set_tick_params(bottom=True, top=randu(1)[0]>0.5)
if randu(1)[0]>0.5:
ax.spines['top'].set_visible(False)
ax.xaxis.set_tick_params(top=False)
if randu(1)[0]>0.5:
axes_x_pos = randu(1)[0]
ax.spines['bottom'].set_position(('axes',axes_x_pos))
# TICKS STYLE AND LOCATION (Y AXIS)
if randu(1)[0]>0.5:
axes_y_pos = 1
ax.yaxis.tick_right()
ax.yaxis.set_label_position("right")
if weid_ticks_prob > 0.6:
ax.yaxis.set_tick_params(width=tick_size[0], length=tick_size[1], color='black', pad=pad_y,
direction= direction_ticks_y, left=randu(1)[0]>0.5, right=True)
else:
ax.yaxis.set_tick_params(left=randu(1)[0]>0.5, right=True)
if randu(1)[0]>0.5:
ax.spines['left'].set_visible(False)
ax.yaxis.set_tick_params(left=False)
if randu(1)[0]>0.5:
axes_y_pos = randu(1)[0]
ax.spines['right'].set_position(('axes',axes_y_pos))
else:
axes_y_pos = 0
if weid_ticks_prob >0.6:
ax.yaxis.set_tick_params(width=tick_size[0], length=tick_size[1], color='black', pad=pad_y,
direction= direction_ticks_y, left=True, right=randu(1)[0]>0.5)
else:
ax.yaxis.set_tick_params(left=True, right=randu(1)[0]>0.5)
if randu(1)[0]>0.5:
ax.spines['right'].set_visible(False)
ax.yaxis.set_tick_params(right=False)
if randu(1)[0]>0.5:
axes_y_pos = randu(1)[0]
ax.spines['left'].set_position(('axes',axes_y_pos))
# LABEL ROTATION
if randu(1)[0]>0.77:
plt.xticks(rotation=int(randu(1)[0]*90))
if randu(1)[0]>0.77:
plt.yticks(rotation=int(randu(1)[0]*90))
# SUB-TICKs
if weid_ticks_prob > 0.6:
color_subtick = random.choice(color_subtick_list)
length_subtick = 0.75*randu(1)[0]*tick_size[1]
if randu(1)[0]>0.7:
minorLocator = AutoMinorLocator()
ax.xaxis.set_minor_locator(minorLocator)
ax.xaxis.set_tick_params(which='minor', length=length_subtick, direction= direction_ticks_x, color=color_subtick,
bottom= ax.spines['bottom'].get_visible(), top=ax.spines['top'].get_visible())
if randu(1)[0]>0.7:
minorLocator = AutoMinorLocator()
ax.yaxis.set_minor_locator(minorLocator)
ax.yaxis.set_tick_params(which='minor', length=length_subtick, direction= direction_ticks_y, color=color_subtick,
left= ax.spines['left'].get_visible(), right= ax.spines['right'].get_visible())
# FONT AND SIZE FOR LABELS (tick labels, axes labels and title)
font = random.choice(font_list)
size_ticks = int(tick_label_size_min + randu(1)[0]*(tick_label_size_max-tick_label_size_min))
size_axes = int(axes_label_size_min + randu(1)[0]*(axes_label_size_max-axes_label_size_min))
size_title = int(title_size_min + randu(1)[0]*(title_size_max-title_size_min))
ticks_font = font_manager.FontProperties(fname = font, style='normal', size=size_ticks, weight='normal', stretch='normal')
axes_font = font_manager.FontProperties(fname = font, style='normal', size=size_axes, weight='normal', stretch='normal')
title_font = font_manager.FontProperties(fname = font, style='normal', size=size_title, weight='normal', stretch='normal')
# TEXTS FOR AXIS LABELS AND TITLE
label_x_length = int(axes_label_length_min + randu(1)[0]*(axes_label_length_max-axes_label_length_min))
label_y_length = int(axes_label_length_min + randu(1)[0]*(axes_label_length_max-axes_label_length_min))
title_length = int(title_length_min + randu(1)[0]*(title_length_max-title_length_min))
x_label = ("".join( [random.choice(string.ascii_letters+' ') for i in range(label_x_length)] )).strip()
y_label = ("".join( [random.choice(string.ascii_letters+' ') for i in range(label_y_length)] )).strip()
title = ("".join( [random.choice(string.ascii_letters+' ') for i in range(title_length)] )).strip()
plt.xlabel(x_label , fontproperties = axes_font)
plt.ylabel(y_label , fontproperties = axes_font, color='black')
if axes_x_pos==1:
plt.title(title, fontproperties = title_font, color='black',y=1.1)
else:
plt.title(title, fontproperties = title_font, color='black')
for label in ax.get_xticklabels():
label.set_fontproperties(ticks_font)
for label in ax.get_yticklabels():
label.set_fontproperties(ticks_font)
# GRID
if randu(1)[0]>0.7:
plt.grid(b=True, which='major', color=random.choice(color_grid), linestyle=random.choice(linestyles))
# AXIS LIMITS
xmin = min(x)
xmax = max(x)
deltax = 0.05*abs(xmax-xmin)
plt.xlim(xmin - deltax, xmax + deltax)
ymin = min(y)
ymax = max(y)
deltay = 0.05*abs(ymax-ymin)
plt.ylim(ymin - deltay, ymax + deltay)
# BACKGROUND AND PATCH COLORS
if randu(1)[0]>0.75:
color_bg = (1-colorbg_transparant_max)+colorbg_transparant_max*randu(3)
ax.set_facecolor(color_bg)
if randu(1)[0]>0.75:
color_bg = (1-colorbg_transparant_max)+colorbg_transparant_max*randu(3)
fig.patch.set_facecolor(color_bg)
# MAKE SURE THE PLOT FITS INSIDE THE FIGURES
plt.tight_layout()
# plt.savefig(os.path.join(direc,name), dpi='figure', facecolor=fig.get_facecolor())
plt.savefig("./data/{}/".format(direc)+name, dpi='figure', facecolor=fig.get_facecolor())
return ax, fig, x, y, s, categories, tick_size, axes_x_pos, axes_y_pos
def test_fit_2gauss_e1e2_errors(ntrial, ellip, s2n,
dopsf=False):
import esutil as eu
import biggles
numpy.random.seed(35)
ngauss=2
npars=2*ngauss+4
title='e: %.2f S/N: %d Ntrial: %d' % (ellip,s2n,ntrial)
outfile='test-2gauss-errors-e%.2f-s2n%d-N%d'
outfile=outfile % (ellip,s2n,ntrial)
if dopsf:
title += ' PSF'
outfile += '-psf'
outfile += '.rec'
if os.path.exists(outfile):
print >>stderr,'reading:',outfile
data=eu.io.read(outfile)
else:
dt = [('pars','f8',npars),
('popt','f8',npars),
('perr','f8',npars),
('pcov','f8',(npars,npars))]
data=zeros(ntrial,dtype=dt)
i=0
ntry=0
while i < ntrial:
newseed = int(randu()*10000000)
pars, popt, perr, pcov = \
test_fit_2gauss_e1e2(ellip=ellip,
seed=newseed,
s2n=s2n,
dopsf=dopsf)
ntry+= 1
if perr is not None:
data['pars'][i,:] = pars
data['popt'][i,:] = popt
data['perr'][i,:] = perr
data['pcov'][i,:,:] = pcov
i += 1
print >>stderr,"ntry:",ntry
print >>stderr,"good frac:",float(ntrial)/ntry
print >>stderr,'writing:',outfile
eu.io.write(outfile,data,clobber=True)
biggles.configure('fontsize_min', 1.0)
biggles.configure('linewidth',1.0) # frame only
nrows=3
ncols=3
tab=biggles.Table(nrows,ncols)
#for par in [0,1,2,3]:
for par in xrange(npars):
diff=data['popt'][:,par] - data['pars'][:,par]
chi = diff/data['perr'][:,par]
std=chi.std()
binsize=0.2*std
plt=eu.plotting.bhist(chi, binsize=binsize,show=False)
if par==0:
xlabel=r'$(x_0-x_0^{true})/\sigma$'
elif par == 1:
xlabel=r'$(y_0-y_0^{true})/\sigma$'
elif par == 2:
xlabel=r'$(e_1-e_1^{true})/\sigma$'
elif par == 3:
xlabel=r'$(e_2-e_2^{true})/\sigma$'
elif par == 4:
xlabel=r'$(p_1-p_1^{true})/\sigma$'
elif par == 5:
xlabel=r'$(p_2-p_2^{true})/\sigma$'
elif par == 6:
xlabel=r'$(T_1-T_1^{true})/\sigma$'
elif par == 7:
xlabel=r'$(T_2-T_2^{true})/\sigma$'
plt.xlabel = xlabel
text=r'$\sigma: %.2f' % std
lab=biggles.PlotLabel(0.1,0.9,text,halign='left')
plt.add(lab)
tab[par//ncols,par%ncols] = plt
tab.title=title
tab.show()
def get_rand_ne(self):
return randu(-180.0, 180.0, 2)
def test_fit_1gauss_galsim(ellip=0.2, s2n=10000):
import images
import galsim
import admom
numpy.random.seed(35)
#sigma = 1.4
sigma = 1
T=2*sigma**2
e = 0.2
theta=23.7
e1,e2 = etheta2e1e2(e,theta)
fimage_cov = ellip2mom(T, e=e, theta=theta)
print 'e: ',e
print 'e1:',e1
print 'e2:',e2
pixel_scale = 1.
nsig=5
dim = int(nsig*T)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2
pix = galsim.Pixel(xw=pixel_scale, yw=pixel_scale)
gobj = galsim.Gaussian(sigma=sigma)
gobj.applyDistortion(galsim.Ellipse(e1=e1,e2=e2))
gcobj = galsim.Convolve([gobj,pix])
im0 = galsim.ImageD(int(dims[1]),int(dims[0]))
gcobj.draw(image=im0, dx=pixel_scale)
images.multiview(im0.array)
galsim_nsub=16
ares = admom.admom(im0.array,cen[0],cen[1],guess=T/2,nsub=galsim_nsub)
print 'galsim sigma:',sqrt( (ares['Irr']+ares['Icc'])/2 )
print 'galsim admom e1:',ares['e1']
print 'galsim admom e2:',ares['e2']
print 'galsim center:',ares['row'],ares['col']
fnsub=16
fim0 = model_image('gauss',dims,cen,fimage_cov,nsub=fnsub)
fares = admom.admom(fim0,cen[0],cen[1],guess=T/2,nsub=fnsub)
print 'fimage sigma:',sqrt( (fares['Irr']+fares['Icc'])/2 )
print 'fimage admom e1:',fares['e1']
print 'fimage admom e2:',fares['e2']
print 'fimage center:',fares['row'],fares['col']
return
theta=23.7*numpy.pi/180.
print >>stderr,'ellip:',ellip
pars=array([cen[0],cen[1],eta,theta,1.,T])
print >>stderr,'pars'
gmix = gmix_fit.pars2gmix_coellip_pick(pars,ptype='eta')
nsub=1
im0=gmix2image_em(gmix,dims,nsub=nsub)
im,skysig = fimage.add_noise(im0, s2n,check=True)
images.multiview(im,title='nsub: %d' % nsub)
p0=pars.copy()
p0[0] += 1*(randu()-0.5) # cen0
p0[1] += 1*(randu()-0.5) # cen1
p0[2] += 0.2*(randu()-0.5) # eta
p0[3] += 0.5*(randu()-0.5) # theta radians
p0[4] += 0.1*(randu()-0.5) # p
p0[5] += 1*(randu()-0.5) # T
print_pars(pars,front='pars: ')
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellip(im, p0, ptype='eta',verbose=True)
print 'numiter:',gf.numiter
print_pars(gf.popt, front='popt: ')
print_pars(gf.perr, front='perr: ')
images.imprint(gf.pcov)
def test_fit_1gauss_e1e2_fix(imove, dopsf=False):
import images
from fimage import etheta2e1e2, ellip2mom
numpy.random.seed(45)
ptype='e1e2'
numpy.random.seed(35)
if dopsf:
print >>stderr,"DOING PSF"
Tpsf = 2.0
epsf = 0.2
theta_psf = 80.0
cov_psf = ellip2mom(Tpsf, e=epsf, theta=theta_psf)
psf=[{'p':1.0,
'irr':cov_psf[0],
'irc':cov_psf[1],
'icc':cov_psf[2]}]
else:
psf=None
theta=23.7
ellip=0.2
e1,e2 = etheta2e1e2(ellip, theta)
sigma = 3.
T=2*sigma**2
nsig=5
dim = int(nsig*T)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1.)/2.
pars=array([cen[0],cen[1],e1,e2,1.,T])
print >>stderr,'pars'
gmix = gmix_fit.pars2gmix_coellip_pick(pars,ptype=ptype)
nsub=1
im=gmix2image_em(gmix,dims,nsub=nsub, psf=psf)
p0=pars.copy()
if imove == 0:
p0[0] += 1*(randu()-0.5) # cen0
elif imove == 1:
p0[1] += 1*(randu()-0.5) # cen1
elif imove == 2:
p0[2] += 0.2*(randu()-0.5) # e1
elif imove == 3:
p0[3] += 0.2*(randu()-0.5) # e2
elif imove == 4:
p0[4] += 0.2*(randu()-0.5) # p
elif imove == 5:
p0[5] += 1*(randu()-0.5) # T
print_pars(pars,front='pars: ')
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellipFix(im, p0, imove, ptype=ptype,
psf=psf,
verbose=True)
print >>stderr,'numiter:',gf.numiter
print_pars(gf.popt,front='popt: ')
print_pars(gf.perr,front='perr: ')
def get_f_p_vals_dev(s2,show=False):
"""
Determine high-resulution Fvals etc. for devaucouleur approximated
by three gaussians
"""
import fimage
from numpy.random import random as randu
from .gmix_fit import GMixFitCoellip
import pprint
Tpsf=1000
Tobj=Tpsf/s2
fvals=array(list(reversed([0.1, 1.86, 12.6])))
#fvals=array(list(reversed([0.0, 0.9268795541243965, 9.627400726500005])))
fvals /= fvals.max()
pvals=array(list(reversed([0.77,0.18,0.046])))
objpars = {'model':'dev', 'cov':[Tobj/2.,0.0,Tobj/2.]}
psfpars = {'model':'gauss', 'cov':[Tpsf/2.,0.0,Tpsf/2.]}
ci0=fimage.convolved.ConvolverGaussFFT(objpars,psfpars)
ci_nonoise = fimage.convolved.TrimmedConvolvedImage(ci0, fluxfrac=.9997)
ci=fimage.convolved.NoisyConvolvedImage(ci_nonoise,1.e8, 1.e8,s2n_method='uw')
psf_guess=array([ci['cen'][0] + 0.01*(randu()-0.5),
ci['cen'][1] + 0.01*(randu()-0.5),
0.01*(randu()-0.5),
0.01*(randu()-0.5),
Tpsf + 0.01*(randu()-0.5),
1.0 + 0.01*(randu()-0.5)])
psf_width=psf_guess.copy()
psf_width[:] = 100
guess=array([ci['cen'][0] + 0.01*(randu()-0.5),
ci['cen'][1] + 0.01*(randu()-0.5),
0.01*(randu()-0.5),
0.01*(randu()-0.5),
Tobj + 0.01*(randu()-0.5),
fvals[1] + 0.01*(randu()-0.5),
fvals[2] + 0.01*(randu()-0.5),
pvals[0] + 0.01*(randu()-0.5),
pvals[1] + 0.01*(randu()-0.5),
pvals[2] + 0.01*(randu()-0.5)])
width=guess.copy()
width[0] = 0.01
width[1] = 0.01
width[5] = .001
width[:] = 100
gm_psf = GMixFitCoellip(ci.psf, ci['skysig_psf'],
psf_guess, psf_width,
Tpositive=True)
psf_gmix=gm_psf.get_gmix()
pprint.pprint(psf_gmix)
gm = GMixFitCoellip(ci.image, ci['skysig'], guess, width,
psf=psf_gmix)
pars=gm.get_pars()
perr=gm.get_perr()
gmix=gm.get_gmix()
pars=pars.reshape(1,pars.size)
get_f_p_vals(pars=pars)
if show:
import images
from .render import gmix2image
model=gmix2image(gmix, ci.image.shape, psf=psf_gmix)
images.compare_images(ci.image, model)
def test_fit_2gauss_e1e2(ellip=0.2,
seed=35,
s2n=-9999,
dopsf=False):
import images
from fimage import etheta2e1e2, add_noise, ellip2mom
numpy.random.seed(seed)
ptype='e1e2'
nsub=1
if dopsf:
print >>stderr,"DOING PSF"
Tpsf = 2.0
epsf = 0.2
#epsf = 0.2
theta_psf = 80.0
cov_psf = ellip2mom(Tpsf, e=epsf, theta=theta_psf)
psf=[{'p':1.0,
'irr':cov_psf[0],
'irc':cov_psf[1],
'icc':cov_psf[2]}]
else:
psf=None
theta=23.7
e1,e2 = etheta2e1e2(ellip, theta)
T1=3.0
T2=6.0
nsig=5
dim = int(nsig*T2)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
p1=0.4
p2=0.6
pars=array([cen[0],cen[1],e1,e2,p1,p2,T1,T2])
gmix = gmix_fit.pars2gmix_coellip_pick(pars,ptype=ptype)
im0=gmix2image_em(gmix,dims,psf=psf,nsub=nsub)
if s2n > 0:
im,skysig = add_noise(im0, s2n,check=True)
else:
im=im0
p0=pars.copy()
p0[0] += 1*(randu()-0.5) # cen0
p0[1] += 1*(randu()-0.5) # cen1
p0[2] += 0.2*(randu()-0.5) # e1
p0[3] += 0.2*(randu()-0.5) # e2
p0[4] += 0.2*(randu()-0.5) # p1
p0[5] += 0.2*(randu()-0.5) # p2
p0[6] += 1*(randu()-0.5) # p2
p0[7] += 1*(randu()-0.5) # p2
print_pars(pars,front='pars: ')
print_pars(p0, front='guess: ')
gf=gmix_fit.GMixFitCoellip(im, p0,
ptype=ptype,
psf=psf,
verbose=True)
print >>stderr,'numiter:',gf.numiter
print_pars(gf.popt,front='popt: ')
if gf.perr is not None:
print_pars(gf.perr,front='perr: ')
return pars, gf.popt, gf.perr, gf.pcov
def test_fit_exp_cov(method='lm'):
import biggles
from fimage import model_image
numpy.random.seed(35)
nsig=7
ngauss=3
npars=2*ngauss+4
nsigma=20
data=numpy.zeros(nsigma,dtype=[('sigma','f8'),('pars','f8',npars)])
sigvals = numpy.linspace(1.5,5.0,nsigma)
for isigma,sigma in enumerate(sigvals):
print '-'*70
T = 2*sigma**2
#T = 2*8.
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
sigma = sqrt( (Irr+Icc)/2. )
dim = int(2*nsig*sigma)
if (dim % 2) == 0:
dim += 1
dims=array([dim,dim])
cen=(dims-1)/2.
cov=[Irr,Irc,Icc]
im = model_image('exp',dims,cen,cov,nsub=16)
ngauss=3
p0 = [cen[0],cen[1],Irr,Irc,Icc, 0.4,0.07,0.55,0.2,3.8]
#p0 = [cen[0],cen[1],Irr,Irc,Icc,
# .9,.8,.6,0.25,7.]
gf=gmix_fit.GMixFitCoellip(im, p0, ptype='cov',
method=method,verbose=True)
if gf.flags != 0:
raise RuntimeError("failed")
print 'numiter:',gf.numiter
if gf.flags != 0:
stop
#pcov = gf.pcov
#err = sqrt(diag(pcov))
for i in xrange(len(gf.popt)):
#print '%.6g %.6g' % (gf.popt[i],err[i])
print '%.6g' % gf.popt[i]
data['sigma'][isigma] = sigma
data['pars'][isigma,:] = gf.popt
# plot the last one
gmix = gmix_fit.pars2gmix_coellip_pick(gf.popt,ptype='cov')
model = gmix2image_em(gmix,im.shape)
images.compare_images(im,model)
biggles.configure('fontsize_min', 1.0)
biggles.configure('linewidth',1.0) # frame only
nrows=3
ncols=4
tab=biggles.Table(nrows,ncols)
for par in xrange(npars):
plt=biggles.FramedPlot()
plt.add(biggles.Curve(data['sigma'],data['pars'][:,par]))
plt.xlabel = r'$\sigma$'
plt.ylabel = 'p%d' % par
tab[par//ncols,par%ncols] = plt
tab.show()
