def make_rgb(imlist, wtlist, nonlinear=0.12, scale=0.0005):
"""
make an rgb image using the input images and weights
"""
import images
# relative_scales = np.array([1.1, 1.0, 2.0])
relative_scales = np.array([1.0, 1.0, 2.0])
scales = scale * relative_scales
noise_fac = 0.1
rminval = noise_fac * np.sqrt(1 / wtlist[2][0, 0])
gminval = noise_fac * np.sqrt(1 / wtlist[1][0, 0])
bminval = noise_fac * np.sqrt(1 / wtlist[0][0, 0])
minval = min(rminval, gminval, bminval)
minval = 0
r = imlist[2].clip(min=minval)
g = imlist[1].clip(min=minval)
b = imlist[0].clip(min=minval)
rgb = images.get_color_image(
r.transpose(),
g.transpose(),
b.transpose(),
scales=scales,
nonlinear=nonlinear,
)
rgb.clip(max=1.0, out=rgb)
return rgb
def fake_rgb(mbobs):
"""
fake rgb from single band
"""
import images
#SCALE=.015*np.sqrt(2.0)
#SCALE=0.001
SCALE = 1.0
relative_scales = np.array([1.0, 1.0, 1.0])
scales = SCALE * relative_scales
r = mbobs[0][0].image
g = r
b = r
rgb = images.get_color_image(
r.transpose(),
g.transpose(),
b.transpose(),
#scales=scales,
#nonlinear=0.12,
nonlinear=0.07,
)
return rgb
def make_frame_jpg(**keys):
from PIL import Image
from numpy import array, flipud
import sdsspy
import esutil as eu
import images
#import biggles
g,gh=sdsspy.read('frame', filter='g', header=True, **keys)
r,rh=sdsspy.read('frame', filter='r', header=True, **keys)
i,ih=sdsspy.read('frame', filter='i', header=True, **keys)
gwcs=eu.wcsutil.WCS(gh)
rwcs=eu.wcsutil.WCS(rh)
iwcs=eu.wcsutil.WCS(ih)
# convert r-band center to ra,dec
rowcen_r=r.shape[0]/2.
colcen_r=r.shape[1]/2.
racen_r,deccen_r = rwcs.image2sky(colcen_r, rowcen_r)
# now see where that falls in the g and i images
gcol,grow=gwcs.sky2image(racen_r, deccen_r)
icol,irow=iwcs.sky2image(racen_r, deccen_r)
gshift=[rowcen_r-grow, colcen_r-gcol]
ishift=[rowcen_r-irow, colcen_r-icol]
g = shift_image(g, gshift)
i = shift_image(i, ishift)
rescale=0.4
scales= rescale*array([5., 6.5, 9.])
nonlinear=0.15
colorim=images.get_color_image(i, r, g,
scales=scales,
nonlinear=nonlinear,
satval=30.)
fname=get_jpg_path(**keys)
print 'writing:',fname
dname=os.path.dirname(fname)
if not os.path.exists(dname):
print 'making dirs:',dname
os.makedirs(dname)
#colorim = (colorim*255).astype('u1')
colorim = images.bytescale(colorim)
colorim=flipud(colorim)
pim=Image.fromarray(colorim)
pim.save(fname, quality=90)
def make_rgb_old(r, g, b):
import images
maxval = max(r.max(), g.max(), b.max())
scales = [1.0 / maxval] * 3
rgb = images.get_color_image(
r.transpose(),
g.transpose(),
b.transpose(),
scales=scales,
nonlinear=0.1,
)
return rgb
def make_image(self):
import images
self._make_imlist()
scales=self._get_scales()
print("using satval:",self.satval)
print('getting color image')
imlist=self.imlist
colorim=images.get_color_image(imlist[2].image,
imlist[1].image,
imlist[0].image,
scales=scales,
nonlinear=NONLINEAR,
satval=self.satval)
print('bytescaling')
colorim = images.bytescale(colorim)
self.colorim=colorim
def make_rgb(mbobs):
import images
#SCALE=.015*np.sqrt(2.0)
SCALE = 0.01
# lsst
#SCALE=0.0005
#relative_scales = np.array([1.00, 1.2, 2.0])
relative_scales = np.array([1.00, 1.0, 2.0])
scales = SCALE * relative_scales
r = mbobs[2][0].image
g = mbobs[1][0].image
b = mbobs[0][0].image
rgb = images.get_color_image(
r.transpose(),
g.transpose(),
b.transpose(),
scales=scales,
nonlinear=0.12,
)
return rgb
def make_image(self):
"""
create the rgb image
"""
import images
self._make_imlist()
scales = self._get_scales()
print("using satval:", self.satval)
print('getting color image')
imlist = self.imlist
colorim = images.get_color_image(imlist[2].image,
imlist[1].image,
imlist[0].image,
scales=scales,
nonlinear=NONLINEAR,
satval=self.satval)
print('bytescaling')
colorim = images.bytescale(colorim)
self.colorim = colorim
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)
def view_atlas(**keys):
"""
View atlas images for the input object
parameters
----------
cat: optional
A full structure with run,rerun,camcol,field,id
run: optional
Run id
rerun: optional
rerun id
camcol: optional
camcol id
field: opt
field id
id: opt
id in field
band: optional
Only display this band
shift:
Apply sub-pixel astronometric shifts, default False
"""
import images
import biggles
import sdsspy
biggles.configure( 'default', 'fontsize_min', 1)
band=keys.get('band',None)
cat=keys.get('cat',None)
show=keys.get('show',True)
color=keys.get('color',False)
shift=keys.get('shift',False)
idinfo=get_id_info(**keys)
imdict=read_atlas(**idinfo)
nonlinear=keys.get('nonlinear', _default_nonlinear)
if band is not None:
bnum=sdsspy.util.FILTERNUM[band]
bchar=sdsspy.util.FILTERCHAR[band]
idinfo['bchar']=bchar
title='%(run)06d-%(camcol)d-%(field)04d-%(id)05d-%(bchar)s' % idinfo
im=imdict['images'][bnum]
plt=images.view(im, nonlinear=nonlinear,show=False)
plt.title=title
lab=biggles.PlotLabel(0.9,0.9,bchar,color='yellow')
plt.add(lab)
if show:
plt.show()
return plt
elif color:
img=imdict['images'][1].transpose()
imr=imdict['images'][2].transpose()
imi=imdict['images'][3].transpose()
if shift:
img,imi=shift_images(imdict, img, imi)
colorim=images.get_color_image(imi,imr,img,
satval=30.,
nonlinear=nonlinear)
s=imdict['images'][0].shape
ranges = ((-0.5, -0.5), (s[1]-0.5, s[0]-0.5))
d = biggles.Density(colorim, ranges)
plt=biggles.FramedPlot()
plt.add(d)
plt.aspect_ratio=s[0]/float(s[1])
title='%(run)06d-%(camcol)d-%(field)04d-%(id)05d' % idinfo
plt.title=title
if show:
plt.show()
return plt
imslist=scale_image_list(imdict['images'], nonlinear)
nrow=2
ncol=3
plt=biggles.FramedArray(nrow,ncol)
title='%(run)06d-%(camcol)d-%(field)04d-%(id)05d' % idinfo
plt.title=title
s=imslist[0].shape
plt.aspect_ratio = s[0]/float(s[1])*2./3.
for i in xrange(5):
bchar=sdsspy.util.FILTERCHAR[i]
row=i/ncol
col=i % ncol
im=imslist[i]
s=im.shape
im = im.transpose()
ranges = ((-0.5, -0.5), (s[1]-0.5, s[0]-0.5))
d = biggles.Density(im, ranges)
#labs=get_shaded_label(0.9,0.9,bchar)
lab=biggles.PlotLabel(0.9,0.9,bchar,color='yellow')
plt[row,col].add(d)
plt[row,col].add(lab)
if show:
plt.show()
return plt
def view_family(**keys):
"""
If cat/index not sent the data will be read if the id info is
sent
"""
import sdsspy
import biggles
import images
from sdsspy.atlas.atlas import NoAtlasImageError
band=keys.get('band',None)
color=keys.get('color',False)
show=keys.get('show',True)
nonlinear=keys.get('nonlinear', _default_nonlinear)
minval=keys.get('min',1.0)
biggles.configure( 'default', 'fontsize_min', 0.75)
if band is None and not color:
raise ValueError("send band= or color=True")
fam,cat,index=read_family(**keys)
if band is not None:
bnum=sdsspy.util.FILTERNUM[band]
bchar=sdsspy.util.FILTERCHAR[band]
children=fam.get_children()
parent=fam.get_parent()
grandparent=fam.get_grandparent()
main_title='%(run)06d-%(camcol)d-%(field)04d-%(id)05d' % cat[index]
if band is not None:
main_title += ' %s' % bchar
run=cat['run'][index]
camcol=cat['camcol'][index]
field=cat['field'][index]
rerun=cat['rerun'][index]
imlist=[]
titles=[]
if grandparent.size > 0:
try:
imd=read_atlas(run=run,camcol=camcol,field=field,
rerun=rerun, id=cat['id'][grandparent[0]])
if band is not None:
im=imd['images'][bnum]
imlist.append(im)
else:
imlist.append(imd)
title='grandparent %d' % cat['id'][grandparent[0]]
titles.append(title)
except NoAtlasImageError:
pass
if parent.size > 0:
try:
imd=read_atlas(run=run,camcol=camcol,field=field,
rerun=rerun, id=cat['id'][parent[0]])
if band is not None:
im=imd['images'][bnum]
imlist.append(im)
else:
imlist.append(imd)
title='parent %d' % cat['id'][parent[0]]
titles.append(title)
except NoAtlasImageError:
pass
for i in xrange(children.size):
try:
imd=read_atlas(run=run,camcol=camcol,field=field,
rerun=rerun, id=cat['id'][children[i]])
if band is not None:
im=imd['images'][bnum]
imlist.append(im)
else:
imlist.append(imd)
title='child %d' % cat['id'][children[i]]
titles.append(title)
except NoAtlasImageError:
pass
ntot = len(imlist)
if ntot == 0:
raise NoAtlasImageError("none of the objects had atlas images")
if band is not None:
imslist=scale_image_list(imlist, nonlinear)
imslist=[im.transpose() for im in imslist]
else:
imslist=[]
for imd in imlist:
img=imd['images'][1].transpose()
imr=imd['images'][2].transpose()
imi=imd['images'][3].transpose()
cim=images.get_color_image(imi,imr,img,
satval=30.,
nonlinear=nonlinear)
imslist.append(cim)
nrow,ncol=get_family_grid(ntot)
plt=biggles.FramedArray(nrow,ncol)
s=imslist[0].shape
plt.aspect_ratio = s[1]/float(s[0])*nrow/float(ncol)
plt.title=main_title
lcolor='gray75'
for i in xrange(ntot):
im=imslist[i]
row=i/ncol
col=i % ncol
# transposed shape
s=im.shape
ranges = ((-0.5, -0.5), (s[0]-0.5, s[1]-0.5))
d = biggles.Density(im, ranges)
plt[row,col].add(d)
lab=biggles.PlotLabel(0.075,0.9,titles[i],halign='left',
color=lcolor)
plt[row,col].add(lab)
if show:
plt.show()
return plt
