def get_galnorm(seeing, pixsc):
from tractor.patch import ModelMask
S = 32
W,H = S*2+1, S*2+1
psf_sigma = seeing / 2.35 / pixsc
tim = tractor.Image(data=np.zeros((H,W)), inverr=np.ones((H,W)),
psf=tractor.NCircularGaussianPSF([psf_sigma], [1.]),
wcs=tractor.NullWCS(pixscale=pixsc))
gal = SimpleGalaxy(tractor.PixPos(S,S), tractor.Flux(1.))
mm = ModelMask(0, 0, W, H)
galmod = gal.getModelPatch(tim, modelMask=mm).patch
galmod = np.maximum(0, galmod)
galmod /= galmod.sum()
return np.sqrt(np.sum(galmod**2))
def fit_general_gaussian(self,
img,
sig1,
xi,
yi,
fluxi,
psf_r=15,
ps=None):
import tractor
H, W = img.shape
ix = int(np.round(xi))
iy = int(np.round(yi))
xlo = max(0, ix - psf_r)
xhi = min(W, ix + psf_r + 1)
ylo = max(0, iy - psf_r)
yhi = min(H, iy + psf_r + 1)
xx, yy = np.meshgrid(np.arange(xlo, xhi), np.arange(ylo, yhi))
r2 = (xx - xi)**2 + (yy - yi)**2
keep = (r2 < psf_r**2)
pix = img[ylo:yhi, xlo:xhi].copy()
ie = np.zeros_like(pix)
ie[keep] = 1. / sig1
psf = tractor.NCircularGaussianPSF([4.], [1.])
tim = tractor.Image(data=pix, inverr=ie, psf=psf)
src = tractor.PointSource(tractor.PixPos(xi - xlo, yi - ylo),
tractor.Flux(fluxi))
tr = tractor.Tractor([tim], [src])
src.pos.addGaussianPrior('x', 0., 1.)
doplot = (ps is not None)
if doplot:
mod0 = tr.getModelImage(0)
tim.freezeAllBut('psf')
psf.freezeAllBut('sigmas')
# print('Optimizing params:')
# tr.printThawedParams()
#print('Parameter step sizes:', tr.getStepSizes())
optargs = dict(priors=False, shared_params=False)
for step in range(50):
dlnp, x, alpha = tr.optimize(**optargs)
if dlnp == 0:
break
# Now fit only the PSF size
tr.freezeParam('catalog')
# print('Optimizing params:')
# tr.printThawedParams()
for step in range(50):
dlnp, x, alpha = tr.optimize(**optargs)
if dlnp == 0:
break
# fwhms.append(psf.sigmas[0] * 2.35 * self.pixscale)
if doplot:
mod1 = tr.getModelImage(0)
chi1 = tr.getChiImage(0)
# Now switch to a non-isotropic PSF
s = psf.sigmas[0]
#print('Isotropic fit sigma', s)
s = np.clip(s, 1., 5.)
tim.psf = tractor.GaussianMixturePSF(1., 0., 0., s**2, s**2, 0.)
#print('Optimizing params:')
#tr.printThawedParams()
try:
for step in range(50):
dlnp, x, alpha = tr.optimize(**optargs)
#print('PSF:', tim.psf)
if dlnp == 0:
break
except:
import traceback
print('Error during fitting PSF in a focus frame; not to worry')
traceback.print_exc()
print(
'(The above was just an error during fitting one star in a focus frame; not to worry.)'
)
# Don't need to re-fit source params because PSF ampl and mean
# can fit for flux and position.
if doplot:
mod2 = tr.getModelImage(0)
chi2 = tr.getChiImage(0)
kwa = dict(vmin=-3 * sig1, vmax=50 * sig1, cmap='gray')
plt.clf()
plt.subplot(2, 3, 1)
plt.title('Image')
dimshow(pix, ticks=False, **kwa)
plt.subplot(2, 3, 2)
plt.title('Initial model')
dimshow(mod0, ticks=False, **kwa)
plt.subplot(2, 3, 3)
plt.title('Isotropic model')
dimshow(mod1, ticks=False, **kwa)
plt.subplot(2, 3, 4)
plt.title('Final model')
dimshow(mod2, ticks=False, **kwa)
plt.subplot(2, 3, 5)
plt.title('Isotropic chi')
dimshow(chi1, vmin=-10, vmax=10, ticks=False)
plt.subplot(2, 3, 6)
plt.title('Final chi')
dimshow(chi2, vmin=-10, vmax=10, ticks=False)
plt.suptitle('PSF fit')
ps.savefig()
return tim.psf.getParams()[-3:]
def main():
# In LSST meas-deblend (on lsst6):
# python examples/suprimePlot.py --data ~dstn/lsst/ACT-data -v 126969 -c 5 --data-range -100 300 --roi 0 500 0 500 --psf psf.fits --image img.fits --sources srcs.fits
from optparse import OptionParser
import sys
parser = OptionParser(usage=('%prog <img> <psf> <srcs>'))
parser.add_option('-v',
'--verbose',
dest='verbose',
action='count',
default=0,
help='Make more verbose')
opt, args = parser.parse_args()
if len(args) != 3:
parser.print_help()
sys.exit(-1)
if opt.verbose == 0:
lvl = logging.INFO
else:
lvl = logging.DEBUG
logging.basicConfig(level=lvl, format='%(message)s', stream=sys.stdout)
imgfn, psffn, srcfn = args
pimg = pyfits.open(imgfn)
if len(pimg) != 4:
print('Image must have 3 extensions')
sys.exit(-1)
img = pimg[1].data
mask = pimg[2].data
maskhdr = pimg[2].header
var = pimg[3].data
del pimg
print('var', var.shape)
#print var
print('mask', mask.shape)
#print mask
print('img', img.shape)
#print img
mask = mask.astype(np.int16)
for bit in range(16):
on = ((mask & (1 << bit)) != 0)
print('Bit', bit, 'has', np.sum(on), 'pixels set')
'''
MP_BAD = 0
Bit 0 has 2500 pixels set
MP_SAT = 1
Bit 1 has 5771 pixels set
MP_INTRP= 2
Bit 2 has 11269 pixels set
MP_CR = 3
Bit 3 has 136 pixels set
MP_EDGE = 4
Bit 4 has 11856 pixels set
HIERARCH MP_DETECTED = 5
Bit 5 has 37032 pixels set
'''
print('Mask header:', maskhdr)
maskplanes = {}
print('Mask planes:')
for card in maskhdr.ascardlist():
if not card.key.startswith('MP_'):
continue
print(card.value, card.key)
maskplanes[card.key[3:]] = card.value
print('Variance range:', var.min(), var.max())
print('Image median:', np.median(img.ravel()))
invvar = 1. / var
invvar[var == 0] = 0.
invvar[var < 0] = 0.
sig = np.sqrt(np.median(var))
H, W = img.shape
for k, v in maskplanes.items():
plt.clf()
I = ((mask & (1 << v)) != 0)
rgb = np.zeros((H, W, 3))
clipimg = np.clip((img - (-3. * sig)) / (13. * sig), 0, 1)
cimg = clipimg.copy()
cimg[I] = 1
rgb[:, :, 0] = cimg
cimg = clipimg.copy()
cimg[I] = 0
rgb[:, :, 1] = cimg
rgb[:, :, 2] = cimg
plt.imshow(rgb, interpolation='nearest', origin='lower')
plt.title(k)
plt.savefig('mask-%s.png' % k.lower())
badmask = sum([(1 << maskplanes[k])
for k in ['BAD', 'SAT', 'INTRP', 'CR']])
# HACK -- left EDGE sucks
badmask += (1 << maskplanes['EDGE'])
#badmask = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3)
#badmask |= (1 << 4)
print('Masking out: 0x%x' % badmask)
invvar[(mask & badmask) != 0] = 0.
assert (all(np.isfinite(img.ravel())))
assert (all(np.isfinite(invvar.ravel())))
psf = pyfits.open(psffn)[0].data
print('psf', psf.shape)
psf /= psf.sum()
from tractor.emfit import em_fit_2d
from tractor.fitpsf import em_init_params
# Create Gaussian mixture model PSF approximation.
S = psf.shape[0]
# number of Gaussian components
K = 3
w, mu, sig = em_init_params(K, None, None, None)
II = psf.copy()
II /= II.sum()
# HIDEOUS HACK
II = np.maximum(II, 0)
print('Multi-Gaussian PSF fit...')
xm, ym = -(S / 2), -(S / 2)
em_fit_2d(II, xm, ym, w, mu, sig)
print('w,mu,sig', w, mu, sig)
mypsf = tractor.GaussianMixturePSF(w, mu, sig)
P = mypsf.getPointSourcePatch(S / 2, S / 2)
mn, mx = psf.min(), psf.max()
ima = dict(interpolation='nearest', origin='lower', vmin=mn, vmax=mx)
plt.clf()
plt.subplot(1, 2, 1)
plt.imshow(psf, **ima)
plt.subplot(1, 2, 2)
pimg = np.zeros_like(psf)
P.addTo(pimg)
plt.imshow(pimg, **ima)
plt.savefig('psf.png')
sig = np.sqrt(np.median(var))
plt.clf()
plt.hist(img.ravel(), 100, range=(-3. * sig, 3. * sig))
plt.savefig('imghist.png')
srcs = fits_table(srcfn)
print('Initial:', len(srcs), 'sources')
# Trim sources with x=0 or y=0
srcs = srcs[(srcs.x != 0) * (srcs.y != 0)]
print('Trim on x,y:', len(srcs), 'sources left')
# Zero out nans & infs
for c in ['theta', 'a', 'b']:
I = np.logical_not(np.isfinite(srcs.get(c)))
srcs.get(c)[I] = 0.
# Set sources with flux=NaN to something more sensible...
I = np.logical_not(np.isfinite(srcs.flux))
srcs.flux[I] = 1.
# Sort sources by flux.
srcs = srcs[np.argsort(-srcs.flux)]
# Trim sources that are way outside the image.
margin = 8. * np.maximum(srcs.a, srcs.b)
H, W = img.shape
srcs = srcs[(srcs.x > -margin) * (srcs.y > -margin) *
(srcs.x < (W + margin) * (srcs.y < (H + margin)))]
print('Trim out-of-bounds:', len(srcs), 'sources left')
wcs = tractor.FitsWcs(Sip(imgfn, 1))
#wcs = tractor.NullWCS()
timg = tractor.Image(data=img,
invvar=invvar,
psf=mypsf,
wcs=wcs,
sky=tractor.ConstantSky(0.),
photocal=tractor.NullPhotoCal(),
name='image')
inverr = timg.getInvError()
assert (all(np.isfinite(inverr.ravel())))
tsrcs = []
for s in srcs:
#pos = tractor.PixPos(s.x, s.y)
pos = tractor.RaDecPos(s.ra, s.dec)
if s.a > 0 and s.b > 0:
eflux = tractor.Flux(s.flux / 2.)
dflux = tractor.Flux(s.flux / 2.)
re, ab, phi = s.a, s.b / s.a, 90. - s.theta
eshape = gal.GalaxyShape(re, ab, phi)
dshape = gal.GalaxyShape(re, ab, phi)
print('Fluxes', eflux, dflux)
tsrc = gal.CompositeGalaxy(pos, eflux, eshape, dflux, dshape)
else:
flux = tractor.Flux(s.flux)
print('Flux', flux)
tsrc = tractor.PointSource(pos, flux)
tsrcs.append(tsrc)
chug = tractor.Tractor([timg])
for src in tsrcs:
if chug.getModelPatch(timg, src) is None:
print('Dropping non-overlapping source:', src)
continue
chug.addSource(src)
print('Kept a total of', len(chug.catalog), 'sources')
ima = dict(interpolation='nearest',
origin='lower',
vmin=-3. * sig,
vmax=10. * sig)
chia = dict(interpolation='nearest', origin='lower', vmin=-5., vmax=5.)
plt.clf()
plt.imshow(img, **ima)
plt.colorbar()
plt.savefig('img.png')
plt.clf()
plt.imshow(invvar, interpolation='nearest', origin='lower')
plt.colorbar()
plt.savefig('invvar.png')
mod = chug.getModelImages()[0]
plt.clf()
plt.imshow(mod, **ima)
plt.colorbar()
plt.savefig('mod-0.png')
chi = chug.getChiImage(0)
plt.clf()
plt.imshow(chi, **chia)
plt.colorbar()
plt.savefig('chi-0.png')
for step in range(5):
cat = chug.getCatalog()
for src in cat:
if chug.getModelPatch(timg, src) is None:
print('Dropping non-overlapping source:', src)
chug.removeSource(src)
print('Kept a total of', len(chug.catalog), 'sources')
#cat = chug.getCatalog()
#for i,src in enumerate([]):
#for i,src in enumerate(chug.getCatalog()):
#for i in range(len(cat)):
i = 0
while i < len(cat):
src = cat[i]
#print 'Step', i
#for j,s in enumerate(cat):
# x,y = timg.getWcs().positionToPixel(s, s.getPosition())
# print ' ',
# if j == i:
# print '*',
# print '(%6.1f, %6.1f)'%(x,y), s
print('Optimizing source', i, 'of', len(cat))
x, y = timg.getWcs().positionToPixel(src.getPosition(), src)
print('(%6.1f, %6.1f)' % (x, y), src)
# pre = src.getModelPatch(timg)
s1 = str(src)
print('src1 ', s1)
dlnp1, X, a = chug.optimizeCatalogFluxes(srcs=[src])
s2 = str(src)
dlnp2, X, a = chug.optimizeCatalogAtFixedComplexityStep(srcs=[src],
sky=False)
s3 = str(src)
#post = src.getModelPatch(timg)
print('src1 ', s1)
print('src2 ', s2)
print('src3 ', s3)
print('dlnp', dlnp1, dlnp2)
if chug.getModelPatch(timg, src) is None:
print('After optimizing, no overlap!')
print('Removing source', src)
chug.removeSource(src)
i -= 1
i += 1
# plt.clf()
# plt.subplot(2,2,1)
# img = timg.getImage()
# (x0,x1,y0,y1) = pre.getExtent()
# plt.imshow(img, **ima)
# ax = plt.axis()
# plt.plot([x0,x0,x1,x1,x0], [y0,y1,y1,y0,y0], 'k-', lw=2)
# plt.axis(ax)
# plt.subplot(2,2,3)
# plt.imshow(pre.getImage(), **ima)
# plt.subplot(2,2,4)
# plt.imshow(post.getImage(), **ima)
# plt.savefig('prepost-s%i-s%03i.png' % (step, i))
#
# mod = chug.getModelImages()[0]
# plt.clf()
# plt.imshow(mod, **ima)
# plt.colorbar()
# plt.savefig('mod-s%i-s%03i.png' % (step, i))
# chi = chug.getChiImage(0)
# plt.clf()
# plt.imshow(chi, **chia)
# plt.colorbar()
# plt.savefig('chi-s%i-s%03i.png' % (step, i))
#dlnp,x,a = chug.optimizeCatalogFluxes()
#print 'fluxes: dlnp', dlnp
#dlnp,x,a = chug.optimizeCatalogAtFixedComplexityStep()
#print 'opt: dlnp', dlnp
mod = chug.getModelImages()[0]
plt.clf()
plt.imshow(mod, **ima)
plt.colorbar()
plt.savefig('mod-%i.png' % (step + 1))
chi = chug.getChiImage(0)
plt.clf()
plt.imshow(chi, **chia)
plt.colorbar()
plt.savefig('chi-%i.png' % (step + 1))
return
for step in range(5):
chug.optimizeCatalogFluxes()
mod = chug.getModelImages()[0]
plt.clf()
plt.imshow(mod, **ima)
plt.colorbar()
plt.savefig('mod-s%i.png' % step)
chi = chug.getChiImage(0)
plt.clf()
plt.imshow(chi, **chia)
plt.colorbar()
plt.savefig('chi-s%i.png' % step)
def run(self, ps=None, focus=False, momentsize=5, n_fwhm=100):
import pylab as plt
from astrometry.util.plotutils import dimshow, plothist
from legacyanalysis.ps1cat import ps1cat
import photutils
import tractor
fn = self.fn
ext = self.ext
pixsc = self.pixscale
F = fitsio.FITS(fn)
primhdr = F[0].read_header()
self.primhdr = primhdr
img, hdr = self.read_raw(F, ext)
self.hdr = hdr
# pre sky-sub
mn, mx = np.percentile(img.ravel(), [25, 98])
self.imgkwa = dict(vmin=mn, vmax=mx, cmap='gray')
if self.debug and ps is not None:
plt.clf()
dimshow(img, **self.imgkwa)
plt.title('Raw image')
ps.savefig()
M = 200
plt.clf()
plt.subplot(2, 2, 1)
dimshow(img[-M:, :M], ticks=False, **self.imgkwa)
plt.subplot(2, 2, 2)
dimshow(img[-M:, -M:], ticks=False, **self.imgkwa)
plt.subplot(2, 2, 3)
dimshow(img[:M, :M], ticks=False, **self.imgkwa)
plt.subplot(2, 2, 4)
dimshow(img[:M, -M:], ticks=False, **self.imgkwa)
plt.suptitle('Raw image corners')
ps.savefig()
img, trim_x0, trim_y0 = self.trim_edges(img)
fullH, fullW = img.shape
if self.debug and ps is not None:
plt.clf()
dimshow(img, **self.imgkwa)
plt.title('Trimmed image')
ps.savefig()
M = 200
plt.clf()
plt.subplot(2, 2, 1)
dimshow(img[-M:, :M], ticks=False, **self.imgkwa)
plt.subplot(2, 2, 2)
dimshow(img[-M:, -M:], ticks=False, **self.imgkwa)
plt.subplot(2, 2, 3)
dimshow(img[:M, :M], ticks=False, **self.imgkwa)
plt.subplot(2, 2, 4)
dimshow(img[:M, -M:], ticks=False, **self.imgkwa)
plt.suptitle('Trimmed corners')
ps.savefig()
band = self.get_band(primhdr)
exptime = primhdr['EXPTIME']
airmass = primhdr['AIRMASS']
print('Band', band, 'Exptime', exptime, 'Airmass', airmass)
zp0 = self.nom.zeropoint(band, ext=self.ext)
sky0 = self.nom.sky(band)
kx = self.nom.fiducial_exptime(band).k_co
# Find the sky value and noise level
sky, sig1 = self.get_sky_and_sigma(img)
sky1 = np.median(sky)
skybr = -2.5 * np.log10(sky1 / pixsc / pixsc / exptime) + zp0
print('Sky brightness: %8.3f mag/arcsec^2' % skybr)
print('Fiducial: %8.3f mag/arcsec^2' % sky0)
img -= sky
self.remove_sky_gradients(img)
# Post sky-sub
mn, mx = np.percentile(img.ravel(), [25, 98])
self.imgkwa = dict(vmin=mn, vmax=mx, cmap='gray')
if ps is not None:
plt.clf()
dimshow(img, **self.imgkwa)
plt.title('Sky-sub image: %s-%s' % (os.path.basename(fn).replace(
'.fits', '').replace('.fz', ''), ext))
plt.colorbar()
ps.savefig()
# Read WCS header and compute boresight
wcs = self.get_wcs(hdr)
ra_ccd, dec_ccd = wcs.pixelxy2radec((fullW + 1) / 2., (fullH + 1) / 2.)
# Detect stars
psfsig = self.nominal_fwhm / 2.35
detsn = self.detection_map(img, sig1, psfsig, ps)
slices = self.detect_sources(detsn, self.det_thresh, ps)
print(len(slices), 'sources detected')
if len(slices) < 20:
slices = self.detect_sources(detsn, 10., ps)
print(len(slices), 'sources detected')
ndetected = len(slices)
camera = primhdr.get('INSTRUME', '').strip().lower()
# -> "decam" / "mosaic3"
meas = dict(band=band,
airmass=airmass,
skybright=skybr,
pixscale=pixsc,
primhdr=primhdr,
hdr=hdr,
wcs=wcs,
ra_ccd=ra_ccd,
dec_ccd=dec_ccd,
extension=ext,
camera=camera,
ndetected=ndetected)
if ndetected == 0:
print('NO SOURCES DETECTED')
return meas
xx, yy = [], []
fx, fy = [], []
mx2, my2, mxy = [], [], []
wmx2, wmy2, wmxy = [], [], []
# "Peak" region to centroid
P = momentsize
H, W = img.shape
for i, slc in enumerate(slices):
y0 = slc[0].start
x0 = slc[1].start
subimg = detsn[slc]
imax = np.argmax(subimg)
y, x = np.unravel_index(imax, subimg.shape)
if (x0 + x) < P or (x0 + x) > W - 1 - P or (y0 + y) < P or (
y0 + y) > H - 1 - P:
#print('Skipping edge peak', x0+x, y0+y)
continue
xx.append(x0 + x)
yy.append(y0 + y)
pkarea = detsn[y0 + y - P:y0 + y + P + 1,
x0 + x - P:x0 + x + P + 1]
from scipy.ndimage.measurements import center_of_mass
cy, cx = center_of_mass(pkarea)
#print('Center of mass', cx,cy)
fx.append(x0 + x - P + cx)
fy.append(y0 + y - P + cy)
#print('x,y', x0+x, y0+y, 'vs centroid', x0+x-P+cx, y0+y-P+cy)
### HACK -- measure source ellipticity
# go back to the image (not detection map)
#subimg = img[slc]
subimg = img[y0 + y - P:y0 + y + P + 1,
x0 + x - P:x0 + x + P + 1].copy()
subimg /= subimg.sum()
ph, pw = subimg.shape
px, py = np.meshgrid(np.arange(pw), np.arange(ph))
mx2.append(np.sum(subimg * (px - cx)**2))
my2.append(np.sum(subimg * (py - cy)**2))
mxy.append(np.sum(subimg * (px - cx) * (py - cy)))
# Gaussian windowed version
s = 1.
wimg = subimg * np.exp(-0.5 * ((px - cx)**2 + (py - cy)**2) / s**2)
wimg /= np.sum(wimg)
wmx2.append(np.sum(wimg * (px - cx)**2))
wmy2.append(np.sum(wimg * (py - cy)**2))
wmxy.append(np.sum(wimg * (px - cx) * (py - cy)))
mx2 = np.array(mx2)
my2 = np.array(my2)
mxy = np.array(mxy)
wmx2 = np.array(wmx2)
wmy2 = np.array(wmy2)
wmxy = np.array(wmxy)
# semi-major/minor axes and position angle
theta = np.rad2deg(np.arctan2(2 * mxy, mx2 - my2) / 2.)
theta = np.abs(theta) * np.sign(mxy)
s = np.sqrt(((mx2 - my2) / 2.)**2 + mxy**2)
a = np.sqrt((mx2 + my2) / 2. + s)
b = np.sqrt((mx2 + my2) / 2. - s)
ell = 1. - b / a
wtheta = np.rad2deg(np.arctan2(2 * wmxy, wmx2 - wmy2) / 2.)
wtheta = np.abs(wtheta) * np.sign(wmxy)
ws = np.sqrt(((wmx2 - wmy2) / 2.)**2 + wmxy**2)
wa = np.sqrt((wmx2 + wmy2) / 2. + ws)
wb = np.sqrt((wmx2 + wmy2) / 2. - ws)
well = 1. - wb / wa
fx = np.array(fx)
fy = np.array(fy)
xx = np.array(xx)
yy = np.array(yy)
if ps is not None:
plt.clf()
dimshow(detsn, vmin=-3, vmax=50, cmap='gray')
ax = plt.axis()
plt.plot(fx, fy, 'go', mec='g', mfc='none', ms=10)
plt.colorbar()
plt.title('Detected sources')
plt.axis(ax)
ps.savefig()
# show centroids too
# plt.plot(xx, yy, 'go', mec='g', mfc='none', ms=8)
# plt.axis(ax)
# ps.savefig()
# if ps is not None:
# plt.clf()
# plt.subplot(2,1,1)
# mx = np.percentile(np.append(mx2,my2), 99)
# ha = dict(histtype='step', range=(0,mx), bins=50)
# plt.hist(mx2, color='b', label='mx2', **ha)
# plt.hist(my2, color='r', label='my2', **ha)
# plt.hist(mxy, color='g', label='mxy', **ha)
# plt.legend()
# plt.xlim(0,mx)
# plt.subplot(2,1,2)
# mx = np.percentile(np.append(wmx2,wmy2), 99)
# ha = dict(histtype='step', range=(0,mx), bins=50, lw=3, alpha=0.3)
# plt.hist(wmx2, color='b', label='wx2', **ha)
# plt.hist(wmy2, color='r', label='wy2', **ha)
# plt.hist(wmxy, color='g', label='wxy', **ha)
# plt.legend()
# plt.xlim(0,mx)
# plt.suptitle('Source moments')
# ps.savefig()
#
# #mx = np.percentile(np.abs(np.append(mxy,wmxy)), 99)
# plt.clf()
# plt.subplot(2,1,1)
# ha = dict(histtype='step', range=(0,1), bins=50)
# plt.hist(ell, color='g', label='ell', **ha)
# plt.hist(well, color='g', lw=3, alpha=0.3, label='windowed ell', **ha)
# plt.legend()
# plt.subplot(2,1,2)
# ha = dict(histtype='step', range=(-90,90), bins=50)
# plt.hist(theta, color='g', label='theta', **ha)
# plt.hist(wtheta, color='g', lw=3, alpha=0.3,
# label='windowed theta', **ha)
# plt.xlim(-90,90)
# plt.legend()
# plt.suptitle('Source ellipticities & angles')
# ps.savefig()
# Cut down to stars whose centroids are within 1 pixel of their peaks...
#keep = (np.hypot(fx - xx, fy - yy) < 2)
#print(sum(keep), 'of', len(keep), 'stars have centroids within 2 of peaks')
#print('mean dx', np.mean(fx-xx), 'dy', np.mean(fy-yy), 'pixels')
#assert(float(sum(keep)) / len(keep) > 0.9)
#fx = fx[keep]
#fy = fy[keep]
apxy = np.vstack((fx, fy)).T
ap = []
aprad_pix = self.aprad / pixsc
aper = photutils.CircularAperture(apxy, aprad_pix)
p = photutils.aperture_photometry(img, aper)
apflux = p.field('aperture_sum')
# Manual aperture photometry to get clipped means in sky annulus
sky_inner_r, sky_outer_r = [r / pixsc for r in self.skyrad]
sky = []
for xi, yi in zip(fx, fy):
ix = int(np.round(xi))
iy = int(np.round(yi))
skyR = int(np.ceil(sky_outer_r))
xlo = max(0, ix - skyR)
xhi = min(W, ix + skyR + 1)
ylo = max(0, iy - skyR)
yhi = min(H, iy + skyR + 1)
xx, yy = np.meshgrid(np.arange(xlo, xhi), np.arange(ylo, yhi))
r2 = (xx - xi)**2 + (yy - yi)**2
inannulus = ((r2 >= sky_inner_r**2) * (r2 < sky_outer_r**2))
skypix = img[ylo:yhi, xlo:xhi][inannulus]
#print('ylo,yhi, xlo,xhi', ylo,yhi, xlo,xhi, 'img subshape', img[ylo:yhi, xlo:xhi].shape, 'inann shape', inannulus.shape)
s, nil = sensible_sigmaclip(skypix)
sky.append(s)
sky = np.array(sky)
apflux2 = apflux - sky * (np.pi * aprad_pix**2)
good = (apflux2 > 0) * (apflux > 0)
apflux = apflux[good]
apflux2 = apflux2[good]
fx = fx[good]
fy = fy[good]
# Read in the PS1 catalog, and keep those within 0.25 deg of CCD center
# and those with main sequence colors
pscat = ps1cat(ccdwcs=wcs)
stars = pscat.get_stars()
#print('Got PS1 stars:', len(stars))
# we add the color term later
ps1band = ps1cat.ps1band[band]
stars.mag = stars.median[:, ps1band]
ok, px, py = wcs.radec2pixelxy(stars.ra, stars.dec)
px -= 1
py -= 1
if ps is not None:
#kwa = dict(vmin=-3*sig1, vmax=50*sig1, cmap='gray')
# Add to the 'detected sources' plot
# mn,mx = np.percentile(img.ravel(), [50,99])
# kwa = dict(vmin=mn, vmax=mx, cmap='gray')
# plt.clf()
# dimshow(img, **kwa)
ax = plt.axis()
#plt.plot(fx, fy, 'go', mec='g', mfc='none', ms=10)
K = np.argsort(stars.mag)
plt.plot(px[K[:10]] - trim_x0,
py[K[:10]] - trim_y0,
'o',
mec='m',
mfc='none',
ms=12,
mew=2)
plt.plot(px[K[10:]] - trim_x0,
py[K[10:]] - trim_y0,
'o',
mec='m',
mfc='none',
ms=8)
plt.axis(ax)
plt.title('PS1 stars')
#plt.colorbar()
ps.savefig()
# we trimmed the image before running detection; re-add that margin
fullx = fx + trim_x0
fully = fy + trim_y0
# Match PS1 to our detections, find offset
radius = self.maxshift / pixsc
I, J, dx, dy = self.match_ps1_stars(px, py, fullx, fully, radius,
stars)
print(len(I), 'spatial matches with large radius', self.maxshift,
'arcsec,', radius, 'pix')
bins = 2 * int(np.ceil(radius))
#print('Histogramming with', bins, 'bins')
histo, xe, ye = np.histogram2d(dx,
dy,
bins=bins,
range=((-radius, radius), (-radius,
radius)))
# smooth histogram before finding peak -- fuzzy matching
from scipy.ndimage.filters import gaussian_filter
histo = gaussian_filter(histo, 1.)
histo = histo.T
mx = np.argmax(histo)
my, mx = np.unravel_index(mx, histo.shape)
shiftx = (xe[mx] + xe[mx + 1]) / 2.
shifty = (ye[my] + ye[my + 1]) / 2.
if ps is not None:
plt.clf()
plothist(dx, dy, range=((-radius, radius), (-radius, radius)))
plt.xlabel('dx (pixels)')
plt.ylabel('dy (pixels)')
plt.title('Offsets to PS1 stars')
ax = plt.axis()
plt.axhline(0, color='b')
plt.axvline(0, color='b')
plt.plot(shiftx, shifty, 'o', mec='m', mfc='none', ms=15, mew=3)
plt.axis(ax)
ps.savefig()
# Refine with smaller search radius
radius2 = 3. / pixsc
I, J, dx, dy = self.match_ps1_stars(px, py, fullx + shiftx,
fully + shifty, radius2, stars)
print(len(J), 'matches to PS1 with small radius', 3, 'arcsec')
shiftx2 = np.median(dx)
shifty2 = np.median(dy)
#print('Stage-1 shift', shiftx, shifty)
#print('Stage-2 shift', shiftx2, shifty2)
sx = shiftx + shiftx2
sy = shifty + shifty2
print('Astrometric shift (%.0f, %.0f) pixels' % (sx, sy))
if self.debug and ps is not None:
plt.clf()
plothist(dx, dy, range=((-radius2, radius2), (-radius2, radius2)))
plt.xlabel('dx (pixels)')
plt.ylabel('dy (pixels)')
plt.title('Offsets to PS1 stars')
ax = plt.axis()
plt.axhline(0, color='b')
plt.axvline(0, color='b')
plt.plot(shiftx2, shifty2, 'o', mec='m', mfc='none', ms=15, mew=3)
plt.axis(ax)
ps.savefig()
if ps is not None:
mn, mx = np.percentile(img.ravel(), [50, 99])
kwa2 = dict(vmin=mn, vmax=mx, cmap='gray')
plt.clf()
dimshow(img, **kwa2)
ax = plt.axis()
plt.plot(fx[J], fy[J], 'go', mec='g', mfc='none', ms=10, mew=2)
plt.plot(px[I] - sx - trim_x0,
py[I] - sy - trim_y0,
'm+',
ms=10,
mew=2)
plt.axis(ax)
plt.title('Matched PS1 stars')
plt.colorbar()
ps.savefig()
plt.clf()
dimshow(img, **kwa2)
ax = plt.axis()
plt.plot(fx[J], fy[J], 'go', mec='g', mfc='none', ms=10, mew=2)
K = np.argsort(stars.mag)
plt.plot(px[K[:10]] - sx - trim_x0,
py[K[:10]] - sy - trim_y0,
'o',
mec='m',
mfc='none',
ms=12,
mew=2)
plt.plot(px[K[10:]] - sx - trim_x0,
py[K[10:]] - sy - trim_y0,
'o',
mec='m',
mfc='none',
ms=8,
mew=2)
plt.axis(ax)
plt.title('All PS1 stars')
plt.colorbar()
ps.savefig()
# Now cut to just *stars* with good colors
stars.gicolor = stars.median[:, 0] - stars.median[:, 2]
keep = (stars.gicolor > 0.4) * (stars.gicolor < 2.7)
stars.cut(keep)
if len(stars) == 0:
print('No overlap or too few stars in PS1')
return None
px = px[keep]
py = py[keep]
# Re-match
I, J, dx, dy = self.match_ps1_stars(px, py, fullx + sx, fully + sy,
radius2, stars)
print('Cut to', len(stars), 'PS1 stars with good colors; matched',
len(I))
nmatched = len(I)
meas.update(dx=sx, dy=sy, nmatched=nmatched)
if focus:
meas.update(img=img,
hdr=hdr,
primhdr=primhdr,
fx=fx,
fy=fy,
px=px - trim_x0 - sx,
py=py - trim_y0 - sy,
sig1=sig1,
stars=stars,
moments=(mx2, my2, mxy, theta, a, b, ell),
wmoments=(wmx2, wmy2, wmxy, wtheta, wa, wb, well),
apflux=apflux,
apflux2=apflux2)
return meas
#print('Mean astrometric shift (arcsec): delta-ra=', -np.mean(dy)*0.263, 'delta-dec=', np.mean(dx)*0.263)
# Compute photometric offset compared to PS1
# as the PS1 minus observed mags
colorterm = self.colorterm_ps1_to_observed(stars.median, band)
stars.mag += colorterm
ps1mag = stars.mag[I]
if False and ps is not None:
plt.clf()
plt.semilogy(ps1mag, apflux2[J], 'b.')
plt.xlabel('PS1 mag')
plt.ylabel('DECam ap flux (with sky sub)')
ps.savefig()
plt.clf()
plt.semilogy(ps1mag, apflux[J], 'b.')
plt.xlabel('PS1 mag')
plt.ylabel('DECam ap flux (no sky sub)')
ps.savefig()
apmag2 = -2.5 * np.log10(apflux2) + zp0 + 2.5 * np.log10(exptime)
apmag = -2.5 * np.log10(apflux) + zp0 + 2.5 * np.log10(exptime)
if ps is not None:
plt.clf()
plt.plot(ps1mag, apmag[J], 'b.', label='No sky sub')
plt.plot(ps1mag, apmag2[J], 'r.', label='Sky sub')
# ax = plt.axis()
# mn = min(ax[0], ax[2])
# mx = max(ax[1], ax[3])
# plt.plot([mn,mx], [mn,mx], 'k-', alpha=0.1)
# plt.axis(ax)
plt.xlabel('PS1 mag')
plt.ylabel('DECam ap mag')
plt.legend(loc='upper left')
plt.title('Zeropoint')
ps.savefig()
dm = ps1mag - apmag[J]
dmag, dsig = sensible_sigmaclip(dm, nsigma=2.5)
print('Mag offset: %8.3f' % dmag)
print('Scatter: %8.3f' % dsig)
if not np.isfinite(dmag) or not np.isfinite(dsig):
print('FAILED TO GET ZEROPOINT!')
meas.update(zp=None)
return meas
from scipy.stats import sigmaclip
goodpix, lo, hi = sigmaclip(dm, low=3, high=3)
dmagmed = np.median(goodpix)
print(len(goodpix), 'stars used for zeropoint median')
print('Using median zeropoint:')
zp_med = zp0 + dmagmed
trans_med = 10.**(-0.4 * (zp0 - zp_med - kx * (airmass - 1.)))
print('Zeropoint %6.3f' % zp_med)
print('Transparency: %.3f' % trans_med)
dm = ps1mag - apmag2[J]
dmag2, dsig2 = sensible_sigmaclip(dm, nsigma=2.5)
#print('Sky-sub mag offset', dmag2)
#print('Scatter', dsig2)
if ps is not None:
plt.clf()
plt.plot(ps1mag,
apmag[J] + dmag - ps1mag,
'b.',
label='No sky sub')
plt.plot(ps1mag, apmag2[J] + dmag2 - ps1mag, 'r.', label='Sky sub')
plt.xlabel('PS1 mag')
plt.ylabel('DECam ap mag - PS1 mag')
plt.legend(loc='upper left')
plt.ylim(-0.25, 0.25)
plt.axhline(0, color='k', alpha=0.25)
plt.title('Zeropoint')
ps.savefig()
zp_obs = zp0 + dmag
transparency = 10.**(-0.4 * (zp0 - zp_obs - kx * (airmass - 1.)))
meas.update(zp=zp_obs, transparency=transparency)
print('Zeropoint %6.3f' % zp_obs)
print('Fiducial %6.3f' % zp0)
print('Transparency: %.3f' % transparency)
# print('Using sky-subtracted values:')
# zp_sky = zp0 + dmag2
# trans_sky = 10.**(-0.4 * (zp0 - zp_sky - kx * (airmass - 1.)))
# print('Zeropoint %6.3f' % zp_sky)
# print('Transparency: %.3f' % trans_sky)
fwhms = []
psf_r = 15
if n_fwhm not in [0, None]:
Jf = J[:n_fwhm]
for i, (xi, yi, fluxi) in enumerate(zip(fx[Jf], fy[Jf], apflux[Jf])):
#print('Fitting source', i, 'of', len(Jf))
ix = int(np.round(xi))
iy = int(np.round(yi))
xlo = max(0, ix - psf_r)
xhi = min(W, ix + psf_r + 1)
ylo = max(0, iy - psf_r)
yhi = min(H, iy + psf_r + 1)
xx, yy = np.meshgrid(np.arange(xlo, xhi), np.arange(ylo, yhi))
r2 = (xx - xi)**2 + (yy - yi)**2
keep = (r2 < psf_r**2)
pix = img[ylo:yhi, xlo:xhi].copy()
ie = np.zeros_like(pix)
ie[keep] = 1. / sig1
#print('fitting source at', ix,iy)
#print('number of active pixels:', np.sum(ie > 0), 'shape', ie.shape)
psf = tractor.NCircularGaussianPSF([4.], [1.])
tim = tractor.Image(data=pix, inverr=ie, psf=psf)
src = tractor.PointSource(tractor.PixPos(xi - xlo, yi - ylo),
tractor.Flux(fluxi))
tr = tractor.Tractor([tim], [src])
#print('Posterior before prior:', tr.getLogProb())
src.pos.addGaussianPrior('x', 0., 1.)
#print('Posterior after prior:', tr.getLogProb())
doplot = (i < 5) * (ps is not None)
if doplot:
mod0 = tr.getModelImage(0)
tim.freezeAllBut('psf')
psf.freezeAllBut('sigmas')
# print('Optimizing params:')
# tr.printThawedParams()
#print('Parameter step sizes:', tr.getStepSizes())
optargs = dict(priors=False, shared_params=False)
for step in range(50):
dlnp, x, alpha = tr.optimize(**optargs)
#print('dlnp', dlnp)
#print('src', src)
#print('psf', psf)
if dlnp == 0:
break
# Now fit only the PSF size
tr.freezeParam('catalog')
# print('Optimizing params:')
# tr.printThawedParams()
for step in range(50):
dlnp, x, alpha = tr.optimize(**optargs)
#print('dlnp', dlnp)
#print('src', src)
#print('psf', psf)
if dlnp == 0:
break
fwhms.append(psf.sigmas[0] * 2.35 * pixsc)
if doplot:
mod1 = tr.getModelImage(0)
chi1 = tr.getChiImage(0)
plt.clf()
plt.subplot(2, 2, 1)
plt.title('Image')
dimshow(pix, **self.imgkwa)
plt.subplot(2, 2, 2)
plt.title('Initial model')
dimshow(mod0, **self.imgkwa)
plt.subplot(2, 2, 3)
plt.title('Final model')
dimshow(mod1, **self.imgkwa)
plt.subplot(2, 2, 4)
plt.title('Final chi')
dimshow(chi1, vmin=-10, vmax=10)
plt.suptitle('PSF fit')
ps.savefig()
fwhms = np.array(fwhms)
fwhm = np.median(fwhms)
print('Median FWHM: %.3f' % np.median(fwhms))
meas.update(seeing=fwhm)
if False and ps is not None:
lo, hi = np.percentile(fwhms, [5, 95])
lo -= 0.1
hi += 0.1
plt.clf()
plt.hist(fwhms, 25, range=(lo, hi), histtype='step', color='b')
plt.xlabel('FWHM (arcsec)')
ps.savefig()
if ps is not None:
plt.clf()
for i, (xi, yi) in enumerate(zip(fx[J], fy[J])[:50]):
ix = int(np.round(xi))
iy = int(np.round(yi))
xlo = max(0, ix - psf_r)
xhi = min(W, ix + psf_r + 1)
ylo = max(0, iy - psf_r)
yhi = min(H, iy + psf_r + 1)
pix = img[ylo:yhi, xlo:xhi]
slc = pix[iy - ylo, :].copy()
slc /= np.sum(slc)
p1 = plt.plot(slc, 'b-', alpha=0.2)
slc = pix[:, ix - xlo].copy()
slc /= np.sum(slc)
p2 = plt.plot(slc, 'r-', alpha=0.2)
ph, pw = pix.shape
cx, cy = pw / 2, ph / 2
if i == 0:
xx = np.linspace(0, pw, 300)
dx = xx[1] - xx[0]
sig = fwhm / pixsc / 2.35
yy = np.exp(-0.5 * (xx - cx)**2 / sig**2) # * np.sum(pix)
yy /= (np.sum(yy) * dx)
p3 = plt.plot(xx, yy, 'k-', zorder=20)
#plt.ylim(-0.2, 1.0)
plt.legend([p1[0], p2[0], p3[0]],
['image slice (y)', 'image slice (x)', 'fit'])
plt.title('PSF fit')
ps.savefig()
return meas
H, W = 100, 100
pixscale = 0.262
ra, dec = 40., 10.
psf_sigma = 1.4 # pixels
v = psf_sigma**2
ps = pixscale / 3600.
wcs = Tan(ra, dec, W / 2. + 0.5, H / 2. + 0.5, -ps, 0., 0., ps, float(W),
float(H))
tim = tractor.Image(data=np.zeros((H, W), np.float32),
inverr=np.ones((H, W), np.float32),
psf=tractor.GaussianMixturePSF(1., 0., 0., v, v, 0.),
wcs=tractor.ConstantFitsWcs(wcs))
src = RexGalaxy(tractor.RaDecPos(ra, dec), tractor.Flux(100.),
LogRadius(0.))
tr = tractor.Tractor([tim], [src])
mod = tr.getModelImage(0)
plt.clf()
plt.imshow(mod, interpolation='nearest', origin='lower')
plt.savefig('rex.png')
# add noise with std 1.
noisy = mod + np.random.normal(size=mod.shape)
# make that the tim's data
tim.data = noisy
# reset the source params
# The cases we'll consider. The list of tuples are the per-pixel
# noise and PSF standard deviation for the two images.
for name, imageset in [
('Case 1: Same noise and PSF', [(1., 2.), (1., 2.)]),
('Case 2: Different noise, same PSF', [(1., 2.), (2., 2.)]),
('Case 3: Same noise, different PSF', [(1., 2.), (1., 4.)]),
('Case 4: Different noise, different PSF', [(1., 2.), (0.5, 4.)]),
]:
print()
print(name)
print()
# We're simulating a single isolated point source
src = tractor.PointSource(tractor.PixPos(W // 2, H // 2),
tractor.Flux(trueflux))
# Produce tractor image objects with noise model, PSF model, etc
tims = []
for noise, psf_size in imageset:
tim = tractor.Image(np.zeros((H, W), np.float32),
inverr=np.ones((H, W), np.float32) * (1. / noise),
psf=tractor.NCircularGaussianPSF([psf_size], [1.]),
photocal=tractor.LinearPhotoCal(1.))
# Create noiseless model image (simulated image)
tr = tractor.Tractor([tim], [src])
mod = tr.getModelImage(0)
tim.data = mod
tims.append(tim)
# First we'll run without any noise added to the images, to get estimates of ideal performance.