def view_mbobs_list(mbobs_list, **kw):
import biggles
import images
import plotting
weight = kw.get('weight', False)
nband = len(mbobs_list[0])
if weight:
grid = plotting.Grid(len(mbobs_list))
plt = biggles.Table(
grid.nrow,
grid.ncol,
)
for i, mbobs in enumerate(mbobs_list):
if nband == 3:
im = make_rgb(mbobs)
else:
im = mbobs[0][0].image
wt = mbobs[0][0].weight
row, col = grid(i)
tplt = images.view_mosaic([im, wt], show=False)
plt[row, col] = tplt
plt.show()
else:
if nband == 3:
imlist = [make_rgb(mbobs) for mbobs in mbobs_list]
else:
imlist = [mbobs[0][0].image for mbobs in mbobs_list]
plt = images.view_mosaic(imlist, **kw)
return plt
def _show_used_pixels(imlist0,wtlist, prompt=True):
import images
oplt=images.view_mosaic(imlist0,show=False)
oplt.title='original'
imlist=[]
for i in xrange(len(imlist0)):
im0=imlist0[i]
wt=wtlist[i]
im=wt*im0
imlist.append(im)
plt=images.view_mosaic(imlist,show=False)
plt.title='image*weight'
if prompt:
oplt.show()
plt.show()
key=raw_input('hit a key (q to quit): ')
if key.lower()=='q':
stop
return plt
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 _doplots(self, id, mindex, icut, img_orig, img, bmask, weight):
import images
imdiff = img_orig - img
lbmask = numpy.log10(1.0 + bmask)
imlist = [img_orig, img, imdiff, lbmask, weight]
imlist = [t - t.min() for t in imlist]
titles = ['image', 'imfix', 'image-imfix', 'bmask', 'weight']
title = '%d-%06d-%02d' % (id, mindex, icut)
pname = '%s-%d-%06d-%02d.png' % (self.front, id, mindex, icut)
pname = os.path.join(self.pdir, pname)
tab = images.view_mosaic(
imlist,
titles=titles,
show=False,
)
tab.title = title
ctab = images.multiview(img, show=False)
tab[1, 2] = ctab[0, 1]
print(" writing:", pname)
tab.write_img(800, 800, pname)
def _set_mask(self, image, weight):
"""
currently one per stamp, random location
"""
mask = self._get_random_mask()
# make a local copy
bmask = numpy.zeros(mask.shape, dtype='i2')
bmask[:,:] = mask[:,:]
# ravel returns a view
imravel = image.ravel()
wtravel = weight.ravel()
bmravel = bmask.ravel()
mess="mask size does not match image"
assert imravel.size == bmravel.size,mess
ibad, = numpy.where(bmravel != 0)
rep=self['masks']['replace_with']
if rep =='noise':
imravel[ibad] = self.rng.normal(
loc=0.0,
scale=self['noise'],
size=ibad.size
)
else:
imravel[ibad] = rep
wtravel[ibad] = 0.0
if False:
import images
images.view_mosaic([mask,image,image-imorig],
titles=['mask','mod image','mod-orig'])
if raw_input('hit a key: ') == 'q':
stop
return bmask
def _doplots(self, id, mindex, icut, img_orig, img, bmask, weight):
import images
imdiff = img_orig - img
lbmask = numpy.log10(1.0 + bmask)
imlist = [img_orig, img, imdiff, lbmask, weight]
imlist = [t - t.min() for t in imlist]
titles = ["image", "imfix", "image-imfix", "bmask", "weight"]
title = "%d-%06d-%02d" % (id, mindex, icut)
pname = "%s-%d-%06d-%02d.png" % (self.front, id, mindex, icut)
pname = os.path.join(self.pdir, pname)
tab = images.view_mosaic(imlist, titles=titles, show=False)
tab.title = title
ctab = images.multiview(img, show=False)
tab[1, 2] = ctab[0, 1]
print(" writing:", pname)
tab.write_img(800, 800, pname)
def view_mbobs_list(mbobs_list, **kw):
import biggles
import images
import plotting
weight = kw.get('weight', False)
nband = len(mbobs_list[0])
if weight:
grid = plotting.Grid(len(mbobs_list))
plt = biggles.Table(
grid.nrow,
grid.ncol,
)
aratio = grid.nrow / (grid.ncol * 2)
plt.aspect_ratio = aratio
for i, mbobs in enumerate(mbobs_list):
if nband == 3:
im = make_rgb(mbobs)
else:
im = mbobs[0][0].image
wt = mbobs[0][0].weight
row, col = grid(i)
tplt = images.view_mosaic([im, wt], show=False)
plt[row, col] = tplt
plt.show(width=2000, height=2000 * aratio)
else:
if nband == 6:
grid = plotting.Grid(len(mbobs_list))
plt = biggles.Table(
grid.nrow,
grid.ncol,
)
#if grid.nrow==1:
# plt.aspect_ratio = grid.nrow/grid.ncol
#else:
#plt.aspect_ratio = grid.nrow/(grid.ncol*2)
plt.aspect_ratio = grid.nrow / grid.ncol
for i, mbobs in enumerate(mbobs_list):
des_im = make_rgb(mbobs[1:1 + 3])
des_wt = mbobs[2][0].weight
cosmos_im = mbobs[4][0].image
cosmos_wt = mbobs[4][0].weight
tplt = images.view_mosaic(
[cosmos_im, des_im, cosmos_wt, des_wt],
titles=['cosmos', 'DES', 'cosmos wt', 'DES wt'],
show=False,
)
row, col = grid(i)
plt[row, col] = tplt
else:
imlist = [mbobs[0][0].image for mbobs in mbobs_list]
plt = images.view_mosaic(imlist, **kw)
return plt
def test(ntrial=1, dim=2000, show=False):
import galsim
import biggles
import images
rng = np.random.RandomState()
nobj_per = 4
nknots = 100
knot_flux_frac = 0.001
nknots_low, nknots_high = 1, 100
nband = 3
noises = [0.0005, 0.001, 0.0015]
scale = 0.263
psf = galsim.Gaussian(fwhm=0.9)
dims = 64, 64
flux_low, flux_high = 0.5, 1.5
r50_low, r50_high = 0.1, 2.0
fracdev_low, fracdev_high = 0.001, 0.99
bulge_colors = np.array([0.5, 1.0, 1.5])
disk_colors = np.array([1.25, 1.0, 0.75])
knots_colors = np.array([1.5, 1.0, 0.5])
sigma = dims[0]/2.0/4.0*scale
maxrad = dims[0]/2.0/2.0 * scale
tm0 = time.time()
nobj_meas = 0
for trial in range(ntrial):
print("trial: %d/%d" % (trial+1, ntrial))
all_band_obj = []
for i in range(nobj_per):
nknots = int(rng.uniform(low=nknots_low, high=nknots_high))
r50 = rng.uniform(low=r50_low, high=r50_high)
flux = rng.uniform(low=flux_low, high=flux_high)
dx, dy = rng.normal(scale=sigma, size=2).clip(
min=-maxrad,
max=maxrad,
)
g1d, g2d = rng.normal(scale=0.2, size=2).clip(max=0.5)
g1b = 0.5*g1d+rng.normal(scale=0.02)
g2b = 0.5*g2d+rng.normal(scale=0.02)
fracdev = rng.uniform(low=fracdev_low, high=fracdev_high)
flux_bulge = fracdev*flux
flux_disk = (1-fracdev)*flux
flux_knots = nknots*knot_flux_frac*flux_disk
print("fracdev:", fracdev, "nknots:", nknots)
bulge_obj = galsim.DeVaucouleurs(
half_light_radius=r50
).shear(g1=g1b, g2=g2b)
disk_obj = galsim.Exponential(
half_light_radius=r50
).shear(g1=g1d, g2=g2d)
knots_obj = galsim.RandomWalk(
npoints=nknots,
profile=disk_obj,
) # .shear(g1=g1d, g2=g2d)
band_objs = []
for band in range(nband):
band_disk = disk_obj.withFlux(flux_disk*disk_colors[band])
band_bulge = bulge_obj.withFlux(flux_bulge*bulge_colors[band])
band_knots = knots_obj.withFlux(flux_knots*knots_colors[band])
obj = galsim.Sum(band_disk, band_bulge, band_knots).shift(
dx=dx,
dy=dy,
)
obj = galsim.Convolve(obj, psf)
band_objs.append(obj)
all_band_obj.append(band_objs)
jacob = ngmix.DiagonalJacobian(
row=0,
col=0,
scale=scale,
)
wcs = jacob.get_galsim_wcs()
psfim = psf.drawImage(wcs=wcs).array
psf_obs = get_psf_obs(psfim, jacob)
dlist = []
for band in range(nband):
band_objects = [o[band] for o in all_band_obj]
obj = galsim.Sum(band_objects)
im = obj.drawImage(nx=dims[1], ny=dims[0], wcs=wcs).array
im = obj.drawImage(nx=dims[1], ny=dims[0], scale=scale).array
im += rng.normal(scale=noises[band], size=im.shape)
wt = im*0 + 1.0/noises[band]**2
dlist.append(
dict(
image=im,
weight=wt,
wcs=wcs,
)
)
mer = MEDSifier(dlist)
mg = mer.get_meds(0)
mr = mer.get_meds(1)
mi = mer.get_meds(2)
nobj = mg.size
print(" found", nobj, "objects")
nobj_meas += nobj
list_of_obs = []
for i in range(nobj):
gobslist = mg.get_obslist(i, weight_type='uberseg')
robslist = mr.get_obslist(i, weight_type='uberseg')
iobslist = mi.get_obslist(i, weight_type='uberseg')
mbo = ngmix.MultiBandObsList()
mbo.append(gobslist)
mbo.append(robslist)
mbo.append(iobslist)
list_of_obs.append(mbo)
for mbo in list_of_obs:
for obslist in mbo:
for obs in obslist:
obs.set_psf(psf_obs)
prior = moflib.get_mof_prior(list_of_obs, "bdf", rng)
mof_fitter = moflib.MOFStamps(
list_of_obs,
"bdf",
prior=prior,
)
band = 2
guess = moflib.get_stamp_guesses(list_of_obs, band, "bdf", rng)
mof_fitter.go(guess)
if show:
# corrected images
tab = biggles.Table(1, 2)
rgb = images.get_color_image(
dlist[2]['image'].transpose(),
dlist[1]['image'].transpose(),
dlist[0]['image'].transpose(),
nonlinear=0.1,
)
rgb *= 1.0/rgb.max()
tab[0, 0] = images.view_mosaic(
[rgb,
mer.seg,
mer.detim],
titles=['image', 'seg', 'detim'],
show=False,
# dims=[dim, dim],
)
imlist = []
for iobj, mobs in enumerate(list_of_obs):
cmobs = mof_fitter.make_corrected_obs(iobj)
gim = images.make_combined_mosaic(
[mobs[0][0].image, cmobs[0][0].image],
)
rim = images.make_combined_mosaic(
[mobs[1][0].image, cmobs[1][0].image],
)
iim = images.make_combined_mosaic(
[mobs[2][0].image, cmobs[2][0].image],
)
rgb = images.get_color_image(
iim.transpose(),
rim.transpose(),
gim.transpose(),
nonlinear=0.1,
)
rgb *= 1.0/rgb.max()
imlist.append(rgb)
plt = images.view_mosaic(imlist, show=False)
tab[0, 1] = plt
tab.show(width=dim*2, height=dim)
if ntrial > 1:
if 'q' == input("hit a key: "):
return
total_time = time.time()-tm0
print("time per group:", total_time/ntrial)
print("time per object:", total_time/nobj_meas)
