def plotPsfSpatialModel(exposure,
psf,
psfCellSet,
showBadCandidates=True,
numSample=128,
matchKernelAmplitudes=False,
keepPlots=True):
"""Plot the PSF spatial model."""
if plt is None:
print >> sys.stderr, "Unable to import matplotlib"
return
noSpatialKernel = afwMath.cast_LinearCombinationKernel(psf.getKernel())
candPos = list()
candFits = list()
badPos = list()
badFits = list()
candAmps = list()
badAmps = list()
for cell in psfCellSet.getCellList():
for cand in cell.begin(False):
cand = algorithmsLib.cast_PsfCandidateF(cand)
if not showBadCandidates and cand.isBad():
continue
candCenter = afwGeom.PointD(cand.getXCenter(), cand.getYCenter())
try:
im = cand.getMaskedImage()
except Exception, e:
continue
fit = algorithmsLib.fitKernelParamsToImage(noSpatialKernel, im,
candCenter)
params = fit[0]
kernels = fit[1]
amp = 0.0
for p, k in zip(params, kernels):
amp += p * afwMath.cast_FixedKernel(k).getSum()
targetFits = badFits if cand.isBad() else candFits
targetPos = badPos if cand.isBad() else candPos
targetAmps = badAmps if cand.isBad() else candAmps
targetFits.append([x / amp for x in params])
targetPos.append(candCenter)
targetAmps.append(amp)
def plotPsfSpatialModel(exposure, psf, psfCellSet, showBadCandidates=True, numSample=128,
matchKernelAmplitudes=False, keepPlots=True):
"""Plot the PSF spatial model."""
if plt is None:
print >> sys.stderr, "Unable to import matplotlib"
return
noSpatialKernel = afwMath.cast_LinearCombinationKernel(psf.getKernel())
candPos = list()
candFits = list()
badPos = list()
badFits = list()
candAmps = list()
badAmps = list()
for cell in psfCellSet.getCellList():
for cand in cell.begin(False):
cand = algorithmsLib.cast_PsfCandidateF(cand)
if not showBadCandidates and cand.isBad():
continue
candCenter = afwGeom.PointD(cand.getXCenter(), cand.getYCenter())
try:
im = cand.getMaskedImage()
except Exception, e:
continue
fit = algorithmsLib.fitKernelParamsToImage(noSpatialKernel, im, candCenter)
params = fit[0]
kernels = fit[1]
amp = 0.0
for p, k in zip(params, kernels):
amp += p * afwMath.cast_FixedKernel(k).getSum()
targetFits = badFits if cand.isBad() else candFits
targetPos = badPos if cand.isBad() else candPos
targetAmps = badAmps if cand.isBad() else candAmps
targetFits.append([x / amp for x in params])
targetPos.append(candCenter)
targetAmps.append(amp)
def showPsfCandidates(exposure, psfCellSet, psf=None, frame=None, normalize=True, showBadCandidates=True,
fitBasisComponents=False, variance=None, chi=None):
"""Display the PSF candidates.
If psf is provided include PSF model and residuals; if normalize is true normalize the PSFs (and residuals)
If chi is True, generate a plot of residuals/sqrt(variance), i.e. chi
If fitBasisComponents is true, also find the best linear combination of the PSF's components (if they exist)
"""
if chi is None:
if variance is not None: # old name for chi
chi = variance
#
# Show us the ccandidates
#
mos = displayUtils.Mosaic()
#
candidateCenters = []
candidateCentersBad = []
candidateIndex = 0
for cell in psfCellSet.getCellList():
for cand in cell.begin(False): # include bad candidates
cand = algorithmsLib.cast_PsfCandidateF(cand)
rchi2 = cand.getChi2()
if rchi2 > 1e100:
rchi2 = numpy.nan
if not showBadCandidates and cand.isBad():
continue
if psf:
im_resid = displayUtils.Mosaic(gutter=0, background=-5, mode="x")
try:
im = cand.getMaskedImage() # copy of this object's image
xc, yc = cand.getXCenter(), cand.getYCenter()
margin = 0 if True else 5
w, h = im.getDimensions()
bbox = afwGeom.BoxI(afwGeom.PointI(margin, margin), im.getDimensions())
if margin > 0:
bim = im.Factory(w + 2*margin, h + 2*margin)
stdev = numpy.sqrt(afwMath.makeStatistics(im.getVariance(), afwMath.MEAN).getValue())
afwMath.randomGaussianImage(bim.getImage(), afwMath.Random())
bim *= stdev
var = bim.getVariance(); var.set(stdev**2); del var
sbim = im.Factory(bim, bbox)
sbim <<= im
del sbim
im = bim
xc += margin; yc += margin
im = im.Factory(im, True)
im.setXY0(cand.getMaskedImage().getXY0())
except:
continue
if not variance:
im_resid.append(im.Factory(im, True))
if True: # tweak up centroids
mi = im
psfIm = mi.getImage()
config = measAlg.SourceMeasurementConfig()
config.centroider.name = "centroid.sdss"
config.slots.centroid = config.centroider.name
schema = afwTable.SourceTable.makeMinimalSchema()
measureSources = config.makeMeasureSources(schema)
catalog = afwTable.SourceCatalog(schema)
config.slots.setupTable(catalog.table)
extra = 10 # enough margin to run the sdss centroider
miBig = mi.Factory(im.getWidth() + 2*extra, im.getHeight() + 2*extra)
miBig[extra:-extra, extra:-extra] = mi
miBig.setXY0(mi.getX0() - extra, mi.getY0() - extra)
mi = miBig; del miBig
exp = afwImage.makeExposure(mi)
exp.setPsf(psf)
footprintSet = afwDet.FootprintSet(mi,
afwDet.Threshold(0.5*numpy.max(psfIm.getArray())),
"DETECTED")
footprintSet.makeSources(catalog)
if len(catalog) == 0:
raise RuntimeError("Failed to detect any objects")
elif len(catalog) == 1:
source = catalog[0]
else: # more than one source; find the once closest to (xc, yc)
for i, s in enumerate(catalog):
d = numpy.hypot(xc - s.getX(), yc - s.getY())
if i == 0 or d < dmin:
source, dmin = s, d
measureSources.applyWithPeak(source, exp)
xc, yc = source.getCentroid()
# residuals using spatial model
try:
chi2 = algorithmsLib.subtractPsf(psf, im, xc, yc)
except:
chi2 = numpy.nan
continue
resid = im
if variance:
resid = resid.getImage()
var = im.getVariance()
var = var.Factory(var, True)
numpy.sqrt(var.getArray(), var.getArray()) # inplace sqrt
resid /= var
im_resid.append(resid)
# Fit the PSF components directly to the data (i.e. ignoring the spatial model)
if fitBasisComponents:
im = cand.getMaskedImage()
im = im.Factory(im, True)
im.setXY0(cand.getMaskedImage().getXY0())
noSpatialKernel = afwMath.cast_LinearCombinationKernel(psf.getKernel())
candCenter = afwGeom.PointD(cand.getXCenter(), cand.getYCenter())
fit = algorithmsLib.fitKernelParamsToImage(noSpatialKernel, im, candCenter)
params = fit[0]
kernels = afwMath.KernelList(fit[1])
outputKernel = afwMath.LinearCombinationKernel(kernels, params)
outImage = afwImage.ImageD(outputKernel.getDimensions())
outputKernel.computeImage(outImage, False)
im -= outImage.convertF()
resid = im
if margin > 0:
bim = im.Factory(w + 2*margin, h + 2*margin)
afwMath.randomGaussianImage(bim.getImage(), afwMath.Random())
bim *= stdev
sbim = im.Factory(bim, bbox)
sbim <<= resid
del sbim
resid = bim
if variance:
resid = resid.getImage()
resid /= var
im_resid.append(resid)
im = im_resid.makeMosaic()
else:
im = cand.getMaskedImage()
if normalize:
im /= afwMath.makeStatistics(im, afwMath.MAX).getValue()
objId = splitId(cand.getSource().getId(), True)["objId"]
if psf:
lab = "%d chi^2 %.1f" % (objId, rchi2)
ctype = ds9.RED if cand.isBad() else ds9.GREEN
else:
lab = "%d flux %8.3g" % (objId, cand.getSource().getPsfFlux())
ctype = ds9.GREEN
mos.append(im, lab, ctype)
if False and numpy.isnan(rchi2):
ds9.mtv(cand.getMaskedImage().getImage(), title="candidate", frame=1)
print "amp", cand.getAmplitude()
im = cand.getMaskedImage()
center = (candidateIndex, xc - im.getX0(), yc - im.getY0())
candidateIndex += 1
if cand.isBad():
candidateCentersBad.append(center)
else:
candidateCenters.append(center)
if variance:
title = "chi(Psf fit)"
else:
title = "Stars & residuals"
mosaicImage = mos.makeMosaic(frame=frame, title=title)
with ds9.Buffering():
for centers, color in ((candidateCenters, ds9.GREEN), (candidateCentersBad, ds9.RED)):
for cen in centers:
bbox = mos.getBBox(cen[0])
ds9.dot("+", cen[1] + bbox.getMinX(), cen[2] + bbox.getMinY(), frame=frame, ctype=color)
return mosaicImage
def plotPsfSpatialModel(exposure, psf, psfCellSet, showBadCandidates=True, numSample=128,
matchKernelAmplitudes=False, keepPlots=True):
"""Plot the PSF spatial model."""
if not plt:
print >> sys.stderr, "Unable to import matplotlib"
return
noSpatialKernel = afwMath.cast_LinearCombinationKernel(psf.getKernel())
candPos = list()
candFits = list()
badPos = list()
badFits = list()
candAmps = list()
badAmps = list()
for cell in psfCellSet.getCellList():
for cand in cell.begin(False):
cand = algorithmsLib.cast_PsfCandidateF(cand)
if not showBadCandidates and cand.isBad():
continue
candCenter = afwGeom.PointD(cand.getXCenter(), cand.getYCenter())
try:
im = cand.getMaskedImage()
except Exception:
continue
fit = algorithmsLib.fitKernelParamsToImage(noSpatialKernel, im, candCenter)
params = fit[0]
kernels = fit[1]
amp = 0.0
for p, k in zip(params, kernels):
amp += p * afwMath.cast_FixedKernel(k).getSum()
targetFits = badFits if cand.isBad() else candFits
targetPos = badPos if cand.isBad() else candPos
targetAmps = badAmps if cand.isBad() else candAmps
targetFits.append([x / amp for x in params])
targetPos.append(candCenter)
targetAmps.append(amp)
numCandidates = len(candFits)
numBasisFuncs = noSpatialKernel.getNBasisKernels()
xGood = numpy.array([pos.getX() for pos in candPos]) - exposure.getX0()
yGood = numpy.array([pos.getY() for pos in candPos]) - exposure.getY0()
zGood = numpy.array(candFits)
ampGood = numpy.array(candAmps)
xBad = numpy.array([pos.getX() for pos in badPos]) - exposure.getX0()
yBad = numpy.array([pos.getY() for pos in badPos]) - exposure.getY0()
zBad = numpy.array(badFits)
ampBad = numpy.array(badAmps)
numBad = len(badPos)
xRange = numpy.linspace(0, exposure.getWidth(), num=numSample)
yRange = numpy.linspace(0, exposure.getHeight(), num=numSample)
kernel = psf.getKernel()
nKernelComponents = kernel.getNKernelParameters()
#
# Figure out how many panels we'll need
#
nPanelX = int(math.sqrt(nKernelComponents))
nPanelY = nKernelComponents//nPanelX
while nPanelY*nPanelX < nKernelComponents:
nPanelX += 1
fig = plt.figure(1)
fig.clf()
try:
fig.canvas._tkcanvas._root().lift() # == Tk's raise, but raise is a python reserved word
except: # protect against API changes
pass
#
# Generator for axes arranged in panels
#
subplots = makeSubplots(fig, 2, 2, Nx=nPanelX, Ny=nPanelY, xgutter=0.06, ygutter=0.06, pygutter=0.04)
for k in range(nKernelComponents):
func = kernel.getSpatialFunction(k)
dfGood = zGood[:,k] - numpy.array([func(pos.getX(), pos.getY()) for pos in candPos])
yMin = dfGood.min()
yMax = dfGood.max()
if numBad > 0:
dfBad = zBad[:,k] - numpy.array([func(pos.getX(), pos.getY()) for pos in badPos])
yMin = min([yMin, dfBad.min()])
yMax = max([yMax, dfBad.max()])
yMin -= 0.05 * (yMax - yMin)
yMax += 0.05 * (yMax - yMin)
yMin = -0.01
yMax = 0.01
fRange = numpy.ndarray((len(xRange), len(yRange)))
for j, yVal in enumerate(yRange):
for i, xVal in enumerate(xRange):
fRange[j][i] = func(xVal, yVal)
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ax = subplots.next()
ax.set_autoscale_on(False)
ax.set_xbound(lower=0, upper=exposure.getHeight())
ax.set_ybound(lower=yMin, upper=yMax)
ax.plot(yGood, dfGood, 'b+')
if numBad > 0:
ax.plot(yBad, dfBad, 'r+')
ax.axhline(0.0)
ax.set_title('Residuals(y)')
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ax = subplots.next()
if matchKernelAmplitudes and k == 0:
vmin = 0.0
vmax = 1.1
else:
vmin = fRange.min()
vmax = fRange.max()
norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax)
im = ax.imshow(fRange, aspect='auto', origin="lower", norm=norm,
extent=[0, exposure.getWidth()-1, 0, exposure.getHeight()-1])
ax.set_title('Spatial poly')
plt.colorbar(im, orientation='horizontal', ticks=[vmin, vmax])
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ax = subplots.next()
ax.set_autoscale_on(False)
ax.set_xbound(lower=0, upper=exposure.getWidth())
ax.set_ybound(lower=yMin, upper=yMax)
ax.plot(xGood, dfGood, 'b+')
if numBad > 0:
ax.plot(xBad, dfBad, 'r+')
ax.axhline(0.0)
ax.set_title('K%d Residuals(x)' % k)
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ax = subplots.next()
if False:
ax.scatter(xGood, yGood, c=dfGood, marker='o')
ax.scatter(xBad, yBad, c=dfBad, marker='x')
ax.set_xbound(lower=0, upper=exposure.getWidth())
ax.set_ybound(lower=0, upper=exposure.getHeight())
ax.set_title('Spatial residuals')
plt.colorbar(im, orientation='horizontal')
else:
calib = exposure.getCalib()
if calib.getFluxMag0()[0] <= 0:
calib = type(calib)()
calib.setFluxMag0(1.0)
with CalibNoThrow():
ax.plot(calib.getMagnitude(candAmps), zGood[:,k], 'b+')
if numBad > 0:
ax.plot(calib.getMagnitude(badAmps), zBad[:,k], 'r+')
ax.set_title('Flux variation')
fig.show()
global keptPlots
if keepPlots and not keptPlots:
# Keep plots open when done
def show():
print "%s: Please close plots when done." % __name__
try:
plt.show()
except:
pass
print "Plots closed, exiting..."
import atexit
atexit.register(show)
keptPlots = True
def showPsfCandidates(exposure, psfCellSet, psf=None, frame=None, normalize=True, showBadCandidates=True,
fitBasisComponents=False, variance=None, chi=None):
"""Display the PSF candidates.
If psf is provided include PSF model and residuals; if normalize is true normalize the PSFs
(and residuals)
If chi is True, generate a plot of residuals/sqrt(variance), i.e. chi
If fitBasisComponents is true, also find the best linear combination of the PSF's components
(if they exist)
"""
if chi is None:
if variance is not None: # old name for chi
chi = variance
#
# Show us the ccandidates
#
mos = displayUtils.Mosaic()
#
candidateCenters = []
candidateCentersBad = []
candidateIndex = 0
for cell in psfCellSet.getCellList():
for cand in cell.begin(False): # include bad candidates
cand = algorithmsLib.cast_PsfCandidateF(cand)
rchi2 = cand.getChi2()
if rchi2 > 1e100:
rchi2 = numpy.nan
if not showBadCandidates and cand.isBad():
continue
if psf:
im_resid = displayUtils.Mosaic(gutter=0, background=-5, mode="x")
try:
im = cand.getMaskedImage() # copy of this object's image
xc, yc = cand.getXCenter(), cand.getYCenter()
margin = 0 if True else 5
w, h = im.getDimensions()
bbox = afwGeom.BoxI(afwGeom.PointI(margin, margin), im.getDimensions())
if margin > 0:
bim = im.Factory(w + 2*margin, h + 2*margin)
stdev = numpy.sqrt(afwMath.makeStatistics(im.getVariance(), afwMath.MEAN).getValue())
afwMath.randomGaussianImage(bim.getImage(), afwMath.Random())
bim.getVariance().set(stdev**2)
bim.assign(im, bbox)
im = bim
xc += margin
yc += margin
im = im.Factory(im, True)
im.setXY0(cand.getMaskedImage().getXY0())
except:
continue
if not variance:
im_resid.append(im.Factory(im, True))
if True: # tweak up centroids
mi = im
psfIm = mi.getImage()
config = measBase.SingleFrameMeasurementTask.ConfigClass()
config.slots.centroid = "base_SdssCentroid"
schema = afwTable.SourceTable.makeMinimalSchema()
measureSources = measBase.SingleFrameMeasurementTask(schema, config=config)
catalog = afwTable.SourceCatalog(schema)
extra = 10 # enough margin to run the sdss centroider
miBig = mi.Factory(im.getWidth() + 2*extra, im.getHeight() + 2*extra)
miBig[extra:-extra, extra:-extra] = mi
miBig.setXY0(mi.getX0() - extra, mi.getY0() - extra)
mi = miBig
del miBig
exp = afwImage.makeExposure(mi)
exp.setPsf(psf)
footprintSet = afwDet.FootprintSet(mi,
afwDet.Threshold(0.5*numpy.max(psfIm.getArray())),
"DETECTED")
footprintSet.makeSources(catalog)
if len(catalog) == 0:
raise RuntimeError("Failed to detect any objects")
measureSources.run(catalog, exp)
if len(catalog) == 1:
source = catalog[0]
else: # more than one source; find the once closest to (xc, yc)
dmin = None # an invalid value to catch logic errors
for i, s in enumerate(catalog):
d = numpy.hypot(xc - s.getX(), yc - s.getY())
if i == 0 or d < dmin:
source, dmin = s, d
xc, yc = source.getCentroid()
# residuals using spatial model
try:
chi2 = algorithmsLib.subtractPsf(psf, im, xc, yc)
except:
chi2 = numpy.nan
continue
resid = im
if variance:
resid = resid.getImage()
var = im.getVariance()
var = var.Factory(var, True)
numpy.sqrt(var.getArray(), var.getArray()) # inplace sqrt
resid /= var
im_resid.append(resid)
# Fit the PSF components directly to the data (i.e. ignoring the spatial model)
if fitBasisComponents:
im = cand.getMaskedImage()
im = im.Factory(im, True)
im.setXY0(cand.getMaskedImage().getXY0())
try:
noSpatialKernel = afwMath.cast_LinearCombinationKernel(psf.getKernel())
except:
noSpatialKernel = None
if noSpatialKernel:
candCenter = afwGeom.PointD(cand.getXCenter(), cand.getYCenter())
fit = algorithmsLib.fitKernelParamsToImage(noSpatialKernel, im, candCenter)
params = fit[0]
kernels = afwMath.KernelList(fit[1])
outputKernel = afwMath.LinearCombinationKernel(kernels, params)
outImage = afwImage.ImageD(outputKernel.getDimensions())
outputKernel.computeImage(outImage, False)
im -= outImage.convertF()
resid = im
if margin > 0:
bim = im.Factory(w + 2*margin, h + 2*margin)
afwMath.randomGaussianImage(bim.getImage(), afwMath.Random())
bim *= stdev
bim.assign(resid, bbox)
resid = bim
if variance:
resid = resid.getImage()
resid /= var
im_resid.append(resid)
im = im_resid.makeMosaic()
else:
im = cand.getMaskedImage()
if normalize:
im /= afwMath.makeStatistics(im, afwMath.MAX).getValue()
objId = splitId(cand.getSource().getId(), True)["objId"]
if psf:
lab = "%d chi^2 %.1f" % (objId, rchi2)
ctype = ds9.RED if cand.isBad() else ds9.GREEN
else:
lab = "%d flux %8.3g" % (objId, cand.getSource().getPsfFlux())
ctype = ds9.GREEN
mos.append(im, lab, ctype)
if False and numpy.isnan(rchi2):
ds9.mtv(cand.getMaskedImage().getImage(), title="candidate", frame=1)
print "amp", cand.getAmplitude()
im = cand.getMaskedImage()
center = (candidateIndex, xc - im.getX0(), yc - im.getY0())
candidateIndex += 1
if cand.isBad():
candidateCentersBad.append(center)
else:
candidateCenters.append(center)
if variance:
title = "chi(Psf fit)"
else:
title = "Stars & residuals"
mosaicImage = mos.makeMosaic(frame=frame, title=title)
with ds9.Buffering():
for centers, color in ((candidateCenters, ds9.GREEN), (candidateCentersBad, ds9.RED)):
for cen in centers:
bbox = mos.getBBox(cen[0])
ds9.dot("+", cen[1] + bbox.getMinX(), cen[2] + bbox.getMinY(), frame=frame, ctype=color)
return mosaicImage
def showPsfCandidates(exposure, psfCellSet, psf=None, frame=None, normalize=True, showBadCandidates=True,
variance=None, chi=None):
"""Display the PSF candidates.
If psf is provided include PSF model and residuals; if normalize is true normalize the PSFs (and residuals)
If chi is True, generate a plot of residuals/sqrt(variance), i.e. chi
"""
if chi is None:
if variance is not None: # old name for chi
chi = variance
#
# Show us the ccandidates
#
mos = displayUtils.Mosaic()
#
candidateCenters = []
candidateCentersBad = []
candidateIndex = 0
for cell in psfCellSet.getCellList():
for cand in cell.begin(False): # include bad candidates
cand = algorithmsLib.cast_PsfCandidateF(cand)
rchi2 = cand.getChi2()
if rchi2 > 1e100:
rchi2 = numpy.nan
if not showBadCandidates and cand.isBad():
continue
if psf:
im_resid = displayUtils.Mosaic(gutter=0, background=-5, mode="x")
try:
im = cand.getMaskedImage() # copy of this object's image
xc, yc = cand.getXCenter(), cand.getYCenter()
margin = 0 if True else 5
w, h = im.getDimensions()
bbox = afwGeom.BoxI(afwGeom.PointI(margin, margin), im.getDimensions())
if margin > 0:
bim = im.Factory(w + 2*margin, h + 2*margin)
stdev = numpy.sqrt(afwMath.makeStatistics(im.getVariance(), afwMath.MEAN).getValue())
afwMath.randomGaussianImage(bim.getImage(), afwMath.Random())
bim *= stdev
var = bim.getVariance(); var.set(stdev**2); del var
sbim = im.Factory(bim, bbox)
sbim <<= im
del sbim
im = bim
xc += margin; yc += margin
im = im.Factory(im, True)
im.setXY0(cand.getMaskedImage().getXY0())
except:
continue
if not variance:
im_resid.append(im.Factory(im, True))
# residuals using spatial model
chi2 = algorithmsLib.subtractPsf(psf, im, xc, yc)
resid = im
if variance:
resid = resid.getImage()
var = im.getVariance()
var = var.Factory(var, True)
numpy.sqrt(var.getArray(), var.getArray()) # inplace sqrt
resid /= var
im_resid.append(resid)
# Fit the PSF components directly to the data (i.e. ignoring the spatial model)
im = cand.getMaskedImage()
im = im.Factory(im, True)
im.setXY0(cand.getMaskedImage().getXY0())
noSpatialKernel = afwMath.cast_LinearCombinationKernel(psf.getKernel())
candCenter = afwGeom.PointD(cand.getXCenter(), cand.getYCenter())
fit = algorithmsLib.fitKernelParamsToImage(noSpatialKernel, im, candCenter)
params = fit[0]
kernels = afwMath.KernelList(fit[1])
outputKernel = afwMath.LinearCombinationKernel(kernels, params)
outImage = afwImage.ImageD(outputKernel.getDimensions())
outputKernel.computeImage(outImage, False)
im -= outImage.convertF()
resid = im
if margin > 0:
bim = im.Factory(w + 2*margin, h + 2*margin)
afwMath.randomGaussianImage(bim.getImage(), afwMath.Random())
bim *= stdev
sbim = im.Factory(bim, bbox)
sbim <<= resid
del sbim
resid = bim
if variance:
resid = resid.getImage()
resid /= var
im_resid.append(resid)
im = im_resid.makeMosaic()
else:
im = cand.getMaskedImage()
if normalize:
im /= afwMath.makeStatistics(im, afwMath.MAX).getValue()
objId = splitId(cand.getSource().getId(), True)["objId"]
if psf:
lab = "%d chi^2 %.1f" % (objId, rchi2)
ctype = ds9.RED if cand.isBad() else ds9.GREEN
else:
lab = "%d flux %8.3g" % (objId, cand.getSource().getPsfFlux())
ctype = ds9.GREEN
mos.append(im, lab, ctype)
if False and numpy.isnan(rchi2):
ds9.mtv(cand.getMaskedImage().getImage(), title="candidate", frame=1)
print "amp", cand.getAmplitude()
im = cand.getMaskedImage()
center = (candidateIndex, xc - im.getX0(), yc - im.getY0())
candidateIndex += 1
if cand.isBad():
candidateCentersBad.append(center)
else:
candidateCenters.append(center)
if variance:
title = "chi(Psf fit)"
else:
title = "Stars & residuals"
mosaicImage = mos.makeMosaic(frame=frame, title=title)
with ds9.Buffering():
for centers, color in ((candidateCenters, ds9.GREEN), (candidateCentersBad, ds9.RED)):
for cen in centers:
bbox = mos.getBBox(cen[0])
ds9.dot("+", cen[1] + bbox.getMinX(), cen[2] + bbox.getMinY(), frame=frame, ctype=color)
return mosaicImage
def plotPsfSpatialModel(exposure, psf, psfCellSet, showBadCandidates=True, numSample=128,
matchKernelAmplitudes=False, keepPlots=True):
"""Plot the PSF spatial model."""
if not plt:
print >> sys.stderr, "Unable to import matplotlib"
return
noSpatialKernel = afwMath.cast_LinearCombinationKernel(psf.getKernel())
candPos = list()
candFits = list()
badPos = list()
badFits = list()
candAmps = list()
badAmps = list()
for cell in psfCellSet.getCellList():
for cand in cell.begin(False):
cand = algorithmsLib.cast_PsfCandidateF(cand)
if not showBadCandidates and cand.isBad():
continue
candCenter = afwGeom.PointD(cand.getXCenter(), cand.getYCenter())
try:
im = cand.getMaskedImage()
except Exception:
continue
fit = algorithmsLib.fitKernelParamsToImage(noSpatialKernel, im, candCenter)
params = fit[0]
kernels = fit[1]
amp = 0.0
for p, k in zip(params, kernels):
amp += p * afwMath.cast_FixedKernel(k).getSum()
targetFits = badFits if cand.isBad() else candFits
targetPos = badPos if cand.isBad() else candPos
targetAmps = badAmps if cand.isBad() else candAmps
targetFits.append([x / amp for x in params])
targetPos.append(candCenter)
targetAmps.append(amp)
numCandidates = len(candFits)
numBasisFuncs = noSpatialKernel.getNBasisKernels()
xGood = numpy.array([pos.getX() for pos in candPos]) - exposure.getX0()
yGood = numpy.array([pos.getY() for pos in candPos]) - exposure.getY0()
zGood = numpy.array(candFits)
ampGood = numpy.array(candAmps)
xBad = numpy.array([pos.getX() for pos in badPos]) - exposure.getX0()
yBad = numpy.array([pos.getY() for pos in badPos]) - exposure.getY0()
zBad = numpy.array(badFits)
ampBad = numpy.array(badAmps)
numBad = len(badPos)
xRange = numpy.linspace(0, exposure.getWidth(), num=numSample)
yRange = numpy.linspace(0, exposure.getHeight(), num=numSample)
kernel = psf.getKernel()
nKernelComponents = kernel.getNKernelParameters()
#
# Figure out how many panels we'll need
#
nPanelX = int(math.sqrt(nKernelComponents))
nPanelY = nKernelComponents//nPanelX
while nPanelY*nPanelX < nKernelComponents:
nPanelX += 1
fig = plt.figure(1)
fig.clf()
try:
fig.canvas._tkcanvas._root().lift() # == Tk's raise, but raise is a python reserved word
except: # protect against API changes
pass
#
# Generator for axes arranged in panels
#
subplots = makeSubplots(fig, 2, 2, Nx=nPanelX, Ny=nPanelY, xgutter=0.06, ygutter=0.06, pygutter=0.04)
for k in range(nKernelComponents):
func = kernel.getSpatialFunction(k)
dfGood = zGood[:,k] - numpy.array([func(pos.getX(), pos.getY()) for pos in candPos])
yMin = dfGood.min()
yMax = dfGood.max()
if numBad > 0:
dfBad = zBad[:,k] - numpy.array([func(pos.getX(), pos.getY()) for pos in badPos])
yMin = min([yMin, dfBad.min()])
yMax = max([yMax, dfBad.max()])
yMin -= 0.05 * (yMax - yMin)
yMax += 0.05 * (yMax - yMin)
yMin = -0.01
yMax = 0.01
fRange = numpy.ndarray((len(xRange), len(yRange)))
for j, yVal in enumerate(yRange):
for i, xVal in enumerate(xRange):
fRange[j][i] = func(xVal, yVal)
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ax = subplots.next()
ax.set_autoscale_on(False)
ax.set_xbound(lower=0, upper=exposure.getHeight())
ax.set_ybound(lower=yMin, upper=yMax)
ax.plot(yGood, dfGood, 'b+')
if numBad > 0:
ax.plot(yBad, dfBad, 'r+')
ax.axhline(0.0)
ax.set_title('Residuals(y)')
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ax = subplots.next()
if matchKernelAmplitudes and k == 0:
vmin = 0.0
vmax = 1.1
else:
vmin = fRange.min()
vmax = fRange.max()
norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax)
im = ax.imshow(fRange, aspect='auto', origin="lower", norm=norm,
extent=[0, exposure.getWidth()-1, 0, exposure.getHeight()-1])
ax.set_title('Spatial poly')
plt.colorbar(im, orientation='horizontal', ticks=[vmin, vmax])
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ax = subplots.next()
ax.set_autoscale_on(False)
ax.set_xbound(lower=0, upper=exposure.getWidth())
ax.set_ybound(lower=yMin, upper=yMax)
ax.plot(xGood, dfGood, 'b+')
if numBad > 0:
ax.plot(xBad, dfBad, 'r+')
ax.axhline(0.0)
ax.set_title('K%d Residuals(x)' % k)
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ax = subplots.next()
if False:
ax.scatter(xGood, yGood, c=dfGood, marker='o')
ax.scatter(xBad, yBad, c=dfBad, marker='x')
ax.set_xbound(lower=0, upper=exposure.getWidth())
ax.set_ybound(lower=0, upper=exposure.getHeight())
ax.set_title('Spatial residuals')
plt.colorbar(im, orientation='horizontal')
else:
calib = exposure.getCalib()
if calib.getFluxMag0()[0] <= 0:
calib = type(calib)()
calib.setFluxMag0(1.0)
with CalibNoThrow():
ax.plot(calib.getMagnitude(candAmps), zGood[:,k], 'b+')
if numBad > 0:
ax.plot(calib.getMagnitude(badAmps), zBad[:,k], 'r+')
ax.set_title('Flux variation')
fig.show()
global keptPlots
if keepPlots and not keptPlots:
# Keep plots open when done
def show():
print "%s: Please close plots when done." % __name__
try:
plt.show()
except:
pass
print "Plots closed, exiting..."
import atexit
atexit.register(show)
keptPlots = True