def getPsfImage(self):
"""Estimate the PSF"""
starSelectorName = "secondMoment"
psfDeterminerName = "pca"
starSelectorClass = measAlg.starSelectorRegistry.get(starSelectorName)
starSelectorConfig = starSelectorClass.ConfigClass()
starSelector = starSelectorClass(starSelectorConfig)
psfDeterminerClass = measAlg.psfDeterminerRegistry.get(psfDeterminerName)
psfDeterminerConfig = psfDeterminerClass.ConfigClass()
psfDeterminer = psfDeterminerClass(psfDeterminerConfig)
psfCandidateList = starSelector.selectStars(self.exposure, self.sourceList)
metadata = dafBase.propertyList()
self.psf, self.psfCellSet = psfDeterminer.determinePsf(self.exposure, psfCandidateList, metadata)
print "Used %d PSF stars (%d good)" % (metadata.get("numAvailStars"), metadata.get("numGoodStars"))
if not self.display:
return
maUtils.showPsf(psf, frame=5)
maUtils.showPsfMosaic(self.exposure, self.psf, frame=6)
def testShowPsfMosaic(self):
""" Test that the showPsfMosaic function works.
This function is usually called without display=None, which would activate ds9
"""
testDisplay = display if display else afwDisplay.getDisplay(
backend="virtualDevice")
mos = showPsfMosaic(self.exposure,
showEllipticity=True,
showFwhm=True,
display=testDisplay)
self.assertTrue(len(mos.images) > 0)
def showPsf(da, distort=False, stampSize=19, nx=7, ny=None, gutterLevel=0.05):
mos = displayUtils.Mosaic(background=gutterLevel, gutter=1)
if ny is None:
ny = 2*nx
dataId = da.dataId.copy()
for ccd in (8, 9, 5, 4, 3, 6, 7, 2, 1, 0):
dataId.update(ccd=ccd)
calexp = da.getDataset("calexp", dataId)[0]
if False:
print calexp.getDetector().getId()
mos.append(maUtils.showPsfMosaic(calexp, stampSize=stampSize,
nx=nx, ny=ny, distort=distort).makeMosaic(mode=nx))
return mos.makeMosaic(mode=5) # Camera is 5x2
def detectAndMeasureWithDM():
### what file are you going to look at? This should be in fits format.
### The test image included in this example contains stars and galaxies in the center only.
imagefile = "test_image_stars.fits"
### open the file in the stack format
exposure = afwImage.ExposureF(imagefile)
im = exposure.getMaskedImage().getImage()
### display the original image
frame = 0
ds9.mtv(exposure, frame=frame, title="Original Image"); frame+=1
### Subtract background.
### To do this, we'll set up a grid of 64x64 pixel areas across th eimage
### Fit the second moment of the pixels in each (which should be bg-dominated) and a fit a smooth function
### Subtract this function.
print "** subtracting background"
#back_size = 256 ## dunno what this is
#back_ctrl = afwMath.BackgroundControl(im.getWidth()//back_size+1, im.getHeight()//back_size +1)
#back_obj = afwMath.makeBackground(im, back_ctrl)
#im -=back_obj.getImageF("LINEAR")
im -= float(np.median(im.getArray()))
ds9.mtv(exposure, frame=frame, title="Background removed"); frame+=1
### Set up the schema
schema = afwTable.SourceTable.makeMinimalSchema()
schema.setVersion(0)
### Create the detection task
config = SourceDetectionTask.ConfigClass()
config.reEstimateBackground = False
detectionTask = SourceDetectionTask(config=config, schema=schema)
### create the measurement task
config = SourceMeasurementTask.ConfigClass()
config.slots.psfFlux = "flux.sinc" # use of the psf flux is hardcoded in secondMomentStarSelector
measureTask = SourceMeasurementTask(schema, config=config)
### Create the measurePsf task
config = MeasurePsfTask.ConfigClass()
starSelector = config.starSelector.apply()
starSelector.name = "objectSize"
#starSelector.config.badFlags = ["flags.pixel.edge", "flags.pixel.cr.center",
# "flags.pixel.interpolated.center", "flags.pixel.saturated.center"]
psfDeterminer = config.psfDeterminer.apply()
psfDeterminer.config.sizeCellX = 128
psfDeterminer.config.sizeCellY = 128
psfDeterminer.config.nStarPerCell = 1
psfDeterminer.config.spatialOrder = 1
psfDeterminer.config.nEigenComponents = 3
measurePsfTask = MeasurePsfTask(config=config, schema=schema)
### Create the output table
tab = afwTable.SourceTable.make(schema)
lsstDebug.getInfo(MeasurePsfTask).display=True
### Process the data
print "*** running detection task..."
sources = detectionTask.run(tab, exposure, sigma=2).sources
print "*** running measure task..."
measureTask.measure(exposure, sources)
print "*** running measurePsf task..."
result = measurePsfTask.run(exposure, sources)
psf = result.psf
cellSet = result.cellSet
### Look at the psf
psfIm = psf.computeImage()
ds9.mtv(psfIm, frame=frame, title = "Psf Image"); frame+=1
### render it on a grid
import lsst.meas.algorithms.utils as measUtils
cellSet = result.cellSet
measUtils.showPsfMosaic(exposure, psf=psf, frame=frame); frame += 1
with ds9.Buffering():
for s in sources:
xy = s.getCentroid()
ds9.dot('+', *xy, ctype=ds9.GREEN, frame=frame)
if s.get("calib.psf.candidate"):
ds9.dot('x', *xy, ctype=ds9.YELLOW, frame=frame)
if s.get("calib.psf.used"):
ds9.dot('o', *xy, size=4, ctype=ds9.RED, frame=frame)
"""
def run(self, exposure, sources, expId=0, matches=None):
"""!Measure the PSF
\param[in,out] exposure Exposure to process; measured PSF will be added.
\param[in,out] sources Measured sources on exposure; flag fields will be set marking
stars chosen by the star selector and the PSF determiner if a schema
was passed to the task constructor.
\param[in] expId Exposure id used for generating random seed.
\param[in] matches A list of lsst.afw.table.ReferenceMatch objects
(\em i.e. of lsst.afw.table.Match
with \c first being of type lsst.afw.table.SimpleRecord and \c second
type lsst.afw.table.SourceRecord --- the reference object and detected
object respectively) as returned by \em e.g. the AstrometryTask.
Used by star selectors that choose to refer to an external catalog.
\return a pipe.base.Struct with fields:
- psf: The measured PSF (also set in the input exposure)
- cellSet: an lsst.afw.math.SpatialCellSet containing the PSF candidates
as returned by the psf determiner.
"""
self.log.info("Measuring PSF")
import lsstDebug
display = lsstDebug.Info(__name__).display
displayExposure = lsstDebug.Info(
__name__).displayExposure # display the Exposure + spatialCells
displayPsfMosaic = lsstDebug.Info(
__name__).displayPsfMosaic # show mosaic of reconstructed PSF(x,y)
displayPsfCandidates = lsstDebug.Info(
__name__).displayPsfCandidates # show mosaic of candidates
displayResiduals = lsstDebug.Info(
__name__).displayResiduals # show residuals
showBadCandidates = lsstDebug.Info(
__name__).showBadCandidates # include bad candidates
normalizeResiduals = lsstDebug.Info(
__name__).normalizeResiduals # normalise residuals by object peak
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
#
# Run star selector
#
selectionResult = self.starSelector.run(exposure=exposure,
sourceCat=sources,
matches=matches)
reserveResult = self.reserve.run(selectionResult.starCat, expId=expId)
psfCandidateList = [
cand for cand, use in zip(selectionResult.psfCandidates,
reserveResult.use) if use
]
if psfCandidateList and self.candidateKey is not None:
for cand in psfCandidateList:
source = cand.getSource()
source.set(self.candidateKey, True)
self.log.info("PSF star selector found %d candidates" %
len(psfCandidateList))
if display:
frame = display
if displayExposure:
ds9.mtv(exposure, frame=frame, title="psf determination")
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
#
# Determine PSF
#
psf, cellSet = self.psfDeterminer.determinePsf(exposure,
psfCandidateList,
self.metadata,
flagKey=self.usedKey)
self.log.info("PSF determination using %d/%d stars." %
(self.metadata.get("numGoodStars"),
self.metadata.get("numAvailStars")))
exposure.setPsf(psf)
if display:
frame = display
if displayExposure:
showPsfSpatialCells(exposure,
cellSet,
showBadCandidates,
frame=frame)
frame += 1
if displayPsfCandidates: # Show a mosaic of PSF candidates
plotPsfCandidates(cellSet, showBadCandidates, frame)
frame += 1
if displayResiduals:
frame = plotResiduals(exposure,
cellSet,
showBadCandidates=showBadCandidates,
normalizeResiduals=normalizeResiduals,
frame=frame)
if displayPsfMosaic:
maUtils.showPsfMosaic(exposure,
psf,
frame=frame,
showFwhm=True)
ds9.scale(0, 1, "linear", frame=frame)
frame += 1
return pipeBase.Struct(
psf=psf,
cellSet=cellSet,
)
def determinePsf(self, exposure, psfCandidateList, metadata=None, flagKey=None):
"""Determine a PSFEX PSF model for an exposure given a list of PSF
candidates.
Parameters
----------
exposure: `lsst.afw.image.Exposure`
Exposure containing the PSF candidates.
psfCandidateList: iterable of `lsst.meas.algorithms.PsfCandidate`
Sequence of PSF candidates typically obtained by detecting sources
and then running them through a star selector.
metadata: metadata, optional
A home for interesting tidbits of information.
flagKey: `lsst.afw.table.Key`, optional
Schema key used to mark sources actually used in PSF determination.
Returns
-------
psf: `lsst.meas.extensions.psfex.PsfexPsf`
The determined PSF.
"""
import lsstDebug
display = lsstDebug.Info(__name__).display
displayExposure = display and \
lsstDebug.Info(__name__).displayExposure # display the Exposure + spatialCells
displayPsfComponents = display and \
lsstDebug.Info(__name__).displayPsfComponents # show the basis functions
showBadCandidates = display and \
lsstDebug.Info(__name__).showBadCandidates # Include bad candidates (meaningless, methinks)
displayResiduals = display and \
lsstDebug.Info(__name__).displayResiduals # show residuals
displayPsfMosaic = display and \
lsstDebug.Info(__name__).displayPsfMosaic # show mosaic of reconstructed PSF(x,y)
normalizeResiduals = lsstDebug.Info(__name__).normalizeResiduals
afwDisplay.setDefaultMaskTransparency(75)
# Normalise residuals by object amplitude
mi = exposure.getMaskedImage()
nCand = len(psfCandidateList)
if nCand == 0:
raise RuntimeError("No PSF candidates supplied.")
#
# How big should our PSF models be?
#
if display: # only needed for debug plots
# construct and populate a spatial cell set
bbox = mi.getBBox(afwImage.PARENT)
psfCellSet = afwMath.SpatialCellSet(bbox, self.config.sizeCellX, self.config.sizeCellY)
else:
psfCellSet = None
sizes = np.empty(nCand)
for i, psfCandidate in enumerate(psfCandidateList):
try:
if psfCellSet:
psfCellSet.insertCandidate(psfCandidate)
except Exception as e:
self.log.debug("Skipping PSF candidate %d of %d: %s", i, len(psfCandidateList), e)
continue
source = psfCandidate.getSource()
quad = afwEll.Quadrupole(source.getIxx(), source.getIyy(), source.getIxy())
rmsSize = quad.getTraceRadius()
sizes[i] = rmsSize
if self.config.kernelSize >= 15:
self.log.warn("NOT scaling kernelSize by stellar quadrupole moment, but using absolute value")
actualKernelSize = int(self.config.kernelSize)
else:
actualKernelSize = 2 * int(self.config.kernelSize * np.sqrt(np.median(sizes)) + 0.5) + 1
if actualKernelSize < self.config.kernelSizeMin:
actualKernelSize = self.config.kernelSizeMin
if actualKernelSize > self.config.kernelSizeMax:
actualKernelSize = self.config.kernelSizeMax
if display:
rms = np.median(sizes)
print("Median PSF RMS size=%.2f pixels (\"FWHM\"=%.2f)" % (rms, 2*np.sqrt(2*np.log(2))*rms))
# If we manually set the resolution then we need the size in pixel
# units
pixKernelSize = actualKernelSize
if self.config.samplingSize > 0:
pixKernelSize = int(actualKernelSize*self.config.samplingSize)
if pixKernelSize % 2 == 0:
pixKernelSize += 1
self.log.trace("Psfex Kernel size=%.2f, Image Kernel Size=%.2f", actualKernelSize, pixKernelSize)
psfCandidateList[0].setHeight(pixKernelSize)
psfCandidateList[0].setWidth(pixKernelSize)
# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- BEGIN PSFEX
#
# Insert the good candidates into the set
#
defaultsFile = os.path.join(os.environ["MEAS_EXTENSIONS_PSFEX_DIR"], "config", "default-lsst.psfex")
args_md = dafBase.PropertySet()
args_md.set("BASIS_TYPE", str(self.config.psfexBasis))
args_md.set("PSFVAR_DEGREES", str(self.config.spatialOrder))
args_md.set("PSF_SIZE", str(actualKernelSize))
args_md.set("PSF_SAMPLING", str(self.config.samplingSize))
prefs = psfex.Prefs(defaultsFile, args_md)
prefs.setCommandLine([])
prefs.addCatalog("psfexPsfDeterminer")
prefs.use()
principalComponentExclusionFlag = bool(bool(psfex.Context.REMOVEHIDDEN)
if False else psfex.Context.KEEPHIDDEN)
context = psfex.Context(prefs.getContextName(), prefs.getContextGroup(),
prefs.getGroupDeg(), principalComponentExclusionFlag)
set = psfex.Set(context)
set.setVigSize(pixKernelSize, pixKernelSize)
set.setFwhm(2*np.sqrt(2*np.log(2))*np.median(sizes))
set.setRecentroid(self.config.recentroid)
catindex, ext = 0, 0
backnoise2 = afwMath.makeStatistics(mi.getImage(), afwMath.VARIANCECLIP).getValue()
ccd = exposure.getDetector()
if ccd:
gain = np.mean(np.array([a.getGain() for a in ccd]))
else:
gain = 1.0
self.log.warn("Setting gain to %g" % (gain,))
pc = 0
contextvalp = []
for i, key in enumerate(context.getName()):
if context.getPcflag(i):
raise RuntimeError("Principal Components can not be accessed")
contextvalp.append(pcval[pc]) # noqa: F821
pc += 1
elif key[0] == ':':
try:
contextvalp.append(exposure.getMetadata().getScalar(key[1:]))
except KeyError:
raise RuntimeError("*Error*: %s parameter not found in the header of %s" %
(key[1:], prefs.getContextName()))
else:
try:
contextvalp.append(np.array([psfCandidateList[_].getSource().get(key)
for _ in range(nCand)]))
except KeyError:
raise RuntimeError("*Error*: %s parameter not found" % (key,))
set.setContextname(i, key)
if display:
frame = 0
if displayExposure:
disp = afwDisplay.Display(frame=frame)
disp.mtv(exposure, title="psf determination")
badBits = mi.getMask().getPlaneBitMask(self.config.badMaskBits)
fluxName = prefs.getPhotfluxRkey()
fluxFlagName = "base_" + fluxName + "_flag"
xpos, ypos = [], []
for i, psfCandidate in enumerate(psfCandidateList):
source = psfCandidate.getSource()
xc, yc = source.getX(), source.getY()
try:
int(xc), int(yc)
except ValueError:
continue
try:
pstamp = psfCandidate.getMaskedImage().clone()
except Exception:
continue
if fluxFlagName in source.schema and source.get(fluxFlagName):
continue
flux = source.get(fluxName)
if flux < 0 or np.isnan(flux):
continue
# From this point, we're configuring the "sample" (PSFEx's version
# of a PSF candidate).
# Having created the sample, we must proceed to configure it, and
# then fini (finalize), or it will be malformed.
try:
sample = set.newSample()
sample.setCatindex(catindex)
sample.setExtindex(ext)
sample.setObjindex(i)
imArray = pstamp.getImage().getArray()
imArray[np.where(np.bitwise_and(pstamp.getMask().getArray(), badBits))] = \
-2*psfex.BIG
sample.setVig(imArray)
sample.setNorm(flux)
sample.setBacknoise2(backnoise2)
sample.setGain(gain)
sample.setX(xc)
sample.setY(yc)
sample.setFluxrad(sizes[i])
for j in range(set.getNcontext()):
sample.setContext(j, float(contextvalp[j][i]))
except Exception as e:
self.log.debug("Exception when processing sample at (%f,%f): %s", xc, yc, e)
continue
else:
set.finiSample(sample)
xpos.append(xc) # for QA
ypos.append(yc)
if displayExposure:
with disp.Buffering():
disp.dot("o", xc, yc, ctype=afwDisplay.CYAN, size=4)
if set.getNsample() == 0:
raise RuntimeError("No good PSF candidates to pass to PSFEx")
# ---- Update min and max and then the scaling
for i in range(set.getNcontext()):
cmin = contextvalp[i].min()
cmax = contextvalp[i].max()
set.setContextScale(i, cmax - cmin)
set.setContextOffset(i, (cmin + cmax)/2.0)
# Don't waste memory!
set.trimMemory()
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- END PSFEX
#
# Do a PSFEX decomposition of those PSF candidates
#
fields = []
field = psfex.Field("Unknown")
field.addExt(exposure.getWcs(), exposure.getWidth(), exposure.getHeight(), set.getNsample())
field.finalize()
fields.append(field)
sets = []
sets.append(set)
psfex.makeit(fields, sets)
psfs = field.getPsfs()
# Flag which objects were actually used in psfex by
good_indices = []
for i in range(sets[0].getNsample()):
index = sets[0].getSample(i).getObjindex()
if index > -1:
good_indices.append(index)
if flagKey is not None:
for i, psfCandidate in enumerate(psfCandidateList):
source = psfCandidate.getSource()
if i in good_indices:
source.set(flagKey, True)
xpos = np.array(xpos)
ypos = np.array(ypos)
numGoodStars = len(good_indices)
avgX, avgY = np.mean(xpos), np.mean(ypos)
psf = psfex.PsfexPsf(psfs[0], geom.Point2D(avgX, avgY))
if False and (displayResiduals or displayPsfMosaic):
ext = 0
frame = 1
diagnostics = True
catDir = "."
title = "psfexPsfDeterminer"
psfex.psfex.showPsf(psfs, set, ext,
[(exposure.getWcs(), exposure.getWidth(), exposure.getHeight())],
nspot=3, trim=5, frame=frame, diagnostics=diagnostics, outDir=catDir,
title=title)
#
# Display code for debugging
#
if display:
assert psfCellSet is not None
if displayExposure:
maUtils.showPsfSpatialCells(exposure, psfCellSet, showChi2=True,
symb="o", ctype=afwDisplay.YELLOW, ctypeBad=afwDisplay.RED,
size=8, display=disp)
if displayResiduals:
disp4 = afwDisplay.Display(frame=4)
maUtils.showPsfCandidates(exposure, psfCellSet, psf=psf, display=disp4,
normalize=normalizeResiduals,
showBadCandidates=showBadCandidates)
if displayPsfComponents:
disp6 = afwDisplay.Display(frame=6)
maUtils.showPsf(psf, display=disp6)
if displayPsfMosaic:
disp7 = afwDisplay.Display(frame=7)
maUtils.showPsfMosaic(exposure, psf, display=disp7, showFwhm=True)
disp.scale('linear', 0, 1)
#
# Generate some QA information
#
# Count PSF stars
#
if metadata is not None:
metadata.set("spatialFitChi2", np.nan)
metadata.set("numAvailStars", nCand)
metadata.set("numGoodStars", numGoodStars)
metadata.set("avgX", avgX)
metadata.set("avgY", avgY)
return psf, psfCellSet
def run(self, exposure, sources, expId=0, matches=None):
"""!Measure the PSF
\param[in,out] exposure Exposure to process; measured PSF will be added.
\param[in,out] sources Measured sources on exposure; flag fields will be set marking
stars chosen by the star selector and the PSF determiner if a schema
was passed to the task constructor.
\param[in] expId Exposure id used for generating random seed.
\param[in] matches A list of lsst.afw.table.ReferenceMatch objects
(\em i.e. of lsst.afw.table.Match
with \c first being of type lsst.afw.table.SimpleRecord and \c second
type lsst.afw.table.SourceRecord --- the reference object and detected
object respectively) as returned by \em e.g. the AstrometryTask.
Used by star selectors that choose to refer to an external catalog.
\return a pipe.base.Struct with fields:
- psf: The measured PSF (also set in the input exposure)
- cellSet: an lsst.afw.math.SpatialCellSet containing the PSF candidates
as returned by the psf determiner.
"""
self.log.info("Measuring PSF")
import lsstDebug
display = lsstDebug.Info(__name__).display
displayExposure = lsstDebug.Info(__name__).displayExposure # display the Exposure + spatialCells
displayPsfMosaic = lsstDebug.Info(__name__).displayPsfMosaic # show mosaic of reconstructed PSF(x,y)
displayPsfCandidates = lsstDebug.Info(__name__).displayPsfCandidates # show mosaic of candidates
displayResiduals = lsstDebug.Info(__name__).displayResiduals # show residuals
showBadCandidates = lsstDebug.Info(__name__).showBadCandidates # include bad candidates
normalizeResiduals = lsstDebug.Info(__name__).normalizeResiduals # normalise residuals by object peak
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
#
# Run star selector
#
psfCandidateList = self.starSelector.run(exposure=exposure, sourceCat=sources,
matches=matches).psfCandidates
reserveList = []
if self.config.reserveFraction > 0 :
random.seed(self.config.reserveSeed*expId)
reserveList = random.sample(psfCandidateList,
int((self.config.reserveFraction)*len(psfCandidateList)))
for cand in reserveList:
psfCandidateList.remove(cand)
if reserveList and self.reservedKey is not None:
for cand in reserveList:
source = cand.getSource()
source.set(self.reservedKey,True)
if psfCandidateList and self.candidateKey is not None:
for cand in psfCandidateList:
source = cand.getSource()
source.set(self.candidateKey, True)
self.log.info("PSF star selector found %d candidates" % len(psfCandidateList))
if self.config.reserveFraction > 0 :
self.log.info("Reserved %d candidates from the fitting" % len(reserveList))
if display:
frame = display
if displayExposure:
ds9.mtv(exposure, frame=frame, title="psf determination")
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
#
# Determine PSF
#
psf, cellSet = self.psfDeterminer.determinePsf(exposure, psfCandidateList, self.metadata,
flagKey=self.usedKey)
self.log.info("PSF determination using %d/%d stars." %
(self.metadata.get("numGoodStars"), self.metadata.get("numAvailStars")))
exposure.setPsf(psf)
if display:
frame = display
if displayExposure:
showPsfSpatialCells(exposure, cellSet, showBadCandidates, frame=frame)
frame += 1
if displayPsfCandidates: # Show a mosaic of PSF candidates
plotPsfCandidates(cellSet, showBadCandidates, frame)
frame += 1
if displayResiduals:
frame = plotResiduals(exposure, cellSet,
showBadCandidates=showBadCandidates,
normalizeResiduals=normalizeResiduals,
frame=frame)
if displayPsfMosaic:
maUtils.showPsfMosaic(exposure, psf, frame=frame, showFwhm=True)
ds9.scale(0, 1, "linear", frame=frame)
frame += 1
return pipeBase.Struct(
psf = psf,
cellSet = cellSet,
)
size=8,
frame=frame,
)
if displayResiduals:
maUtils.showPsfCandidates(
exposure,
psfCellSet,
psf=psf,
frame=4,
normalize=normalizeResiduals,
showBadCandidates=showBadCandidates,
)
if displayPsfComponents:
maUtils.showPsf(psf, frame=6)
if displayPsfMosaic:
maUtils.showPsfMosaic(exposure, psf, frame=7, showFwhm=True)
ds9.ds9Cmd(ds9.selectFrame(frame=7) + " ;scale limits 0 1")
#
# Generate some QA information
#
# Count PSF stars
#
if metadata != None:
metadata.set("spatialFitChi2", np.nan)
metadata.set("numAvailStars", nCand)
metadata.set("numGoodStars", numGoodStars)
metadata.set("avgX", avgX)
metadata.set("avgY", avgY)
psfCellSet = None
return psf, psfCellSet
def run(self, exposure, sources, expId=0, matches=None):
"""!Measure the PSF
@param[in,out] exposure Exposure to process; measured PSF will be added.
@param[in,out] sources Measured sources on exposure; flag fields will be set marking
stars chosen by the star selector and the PSF determiner if a schema
was passed to the task constructor.
@param[in] expId Exposure id used for generating random seed.
@param[in] matches A list of lsst.afw.table.ReferenceMatch objects
(@em i.e. of lsst.afw.table.Match
with @c first being of type lsst.afw.table.SimpleRecord and @c second
type lsst.afw.table.SourceRecord --- the reference object and detected
object respectively) as returned by @em e.g. the AstrometryTask.
Used by star selectors that choose to refer to an external catalog.
@return a pipe.base.Struct with fields:
- psf: The measured PSF (also set in the input exposure)
- cellSet: an lsst.afw.math.SpatialCellSet containing the PSF candidates
as returned by the psf determiner.
"""
self.log.info("Measuring PSF")
import lsstDebug
display = lsstDebug.Info(__name__).display
displayExposure = lsstDebug.Info(__name__).displayExposure # display the Exposure + spatialCells
displayPsfMosaic = lsstDebug.Info(__name__).displayPsfMosaic # show mosaic of reconstructed PSF(x,y)
displayPsfCandidates = lsstDebug.Info(__name__).displayPsfCandidates # show mosaic of candidates
displayResiduals = lsstDebug.Info(__name__).displayResiduals # show residuals
showBadCandidates = lsstDebug.Info(__name__).showBadCandidates # include bad candidates
normalizeResiduals = lsstDebug.Info(__name__).normalizeResiduals # normalise residuals by object peak
#
# Run star selector
#
stars = self.starSelector.run(sourceCat=sources, matches=matches, exposure=exposure)
selectionResult = self.makePsfCandidates.run(stars.sourceCat, exposure=exposure)
self.log.info("PSF star selector found %d candidates" % len(selectionResult.psfCandidates))
reserveResult = self.reserve.run(selectionResult.goodStarCat, expId=expId)
# Make list of psf candidates to send to the determiner (omitting those marked as reserved)
psfDeterminerList = [cand for cand, use
in zip(selectionResult.psfCandidates, reserveResult.use) if use]
if selectionResult.psfCandidates and self.candidateKey is not None:
for cand in selectionResult.psfCandidates:
source = cand.getSource()
source.set(self.candidateKey, True)
self.log.info("Sending %d candidates to PSF determiner" % len(psfDeterminerList))
if display:
frame = 1
if displayExposure:
disp = afwDisplay.Display(frame=frame)
disp.mtv(exposure, title="psf determination")
frame += 1
#
# Determine PSF
#
psf, cellSet = self.psfDeterminer.determinePsf(exposure, psfDeterminerList, self.metadata,
flagKey=self.usedKey)
self.log.info("PSF determination using %d/%d stars." %
(self.metadata.getScalar("numGoodStars"), self.metadata.getScalar("numAvailStars")))
exposure.setPsf(psf)
if display:
frame = display
if displayExposure:
disp = afwDisplay.Display(frame=frame)
showPsfSpatialCells(exposure, cellSet, showBadCandidates, frame=frame)
frame += 1
if displayPsfCandidates: # Show a mosaic of PSF candidates
plotPsfCandidates(cellSet, showBadCandidates=showBadCandidates, frame=frame)
frame += 1
if displayResiduals:
frame = plotResiduals(exposure, cellSet,
showBadCandidates=showBadCandidates,
normalizeResiduals=normalizeResiduals,
frame=frame)
if displayPsfMosaic:
disp = afwDisplay.Display(frame=frame)
maUtils.showPsfMosaic(exposure, psf, display=disp, showFwhm=True)
disp.scale("linear", 0, 1)
frame += 1
return pipeBase.Struct(
psf=psf,
cellSet=cellSet,
)
def determinePsf(self, exposure, psfCandidateList, metadata=None, flagKey=None):
"""Determine a PSFEX PSF model for an exposure given a list of PSF candidates
@param[in] exposure: exposure containing the psf candidates (lsst.afw.image.Exposure)
@param[in] psfCandidateList: a sequence of PSF candidates (each an lsst.meas.algorithms.PsfCandidate);
typically obtained by detecting sources and then running them through a star selector
@param[in,out] metadata a home for interesting tidbits of information
@param[in] flagKey: schema key used to mark sources actually used in PSF determination
@return psf: a meas.extensions.psfex.PsfexPsf
"""
import lsstDebug
display = lsstDebug.Info(__name__).display
displayExposure = display and \
lsstDebug.Info(__name__).displayExposure # display the Exposure + spatialCells
displayPsfComponents = display and \
lsstDebug.Info(__name__).displayPsfComponents # show the basis functions
showBadCandidates = display and \
lsstDebug.Info(__name__).showBadCandidates # Include bad candidates (meaningless, methinks)
displayResiduals = display and \
lsstDebug.Info(__name__).displayResiduals # show residuals
displayPsfMosaic = display and \
lsstDebug.Info(__name__).displayPsfMosaic # show mosaic of reconstructed PSF(x,y)
normalizeResiduals = lsstDebug.Info(__name__).normalizeResiduals
# Normalise residuals by object amplitude
mi = exposure.getMaskedImage()
nCand = len(psfCandidateList)
if nCand == 0:
raise RuntimeError("No PSF candidates supplied.")
#
# How big should our PSF models be?
#
if display: # only needed for debug plots
# construct and populate a spatial cell set
bbox = mi.getBBox(afwImage.PARENT)
psfCellSet = afwMath.SpatialCellSet(bbox, self.config.sizeCellX, self.config.sizeCellY)
else:
psfCellSet = None
sizes = np.empty(nCand)
for i, psfCandidate in enumerate(psfCandidateList):
try:
if psfCellSet:
psfCellSet.insertCandidate(psfCandidate)
except Exception as e:
self.log.debug("Skipping PSF candidate %d of %d: %s", i, len(psfCandidateList), e)
continue
source = psfCandidate.getSource()
quad = afwEll.Quadrupole(source.getIxx(), source.getIyy(), source.getIxy())
rmsSize = quad.getTraceRadius()
sizes[i] = rmsSize
if self.config.kernelSize >= 15:
self.log.warn("NOT scaling kernelSize by stellar quadrupole moment, but using absolute value")
actualKernelSize = int(self.config.kernelSize)
else:
actualKernelSize = 2 * int(self.config.kernelSize * np.sqrt(np.median(sizes)) + 0.5) + 1
if actualKernelSize < self.config.kernelSizeMin:
actualKernelSize = self.config.kernelSizeMin
if actualKernelSize > self.config.kernelSizeMax:
actualKernelSize = self.config.kernelSizeMax
if display:
rms = np.median(sizes)
print("Median PSF RMS size=%.2f pixels (\"FWHM\"=%.2f)" % (rms, 2*np.sqrt(2*np.log(2))*rms))
# If we manually set the resolution then we need the size in pixel units
pixKernelSize = actualKernelSize
if self.config.samplingSize > 0:
pixKernelSize = int(actualKernelSize*self.config.samplingSize)
if pixKernelSize % 2 == 0:
pixKernelSize += 1
self.log.trace("Psfex Kernel size=%.2f, Image Kernel Size=%.2f", actualKernelSize, pixKernelSize)
psfCandidateList[0].setHeight(pixKernelSize)
psfCandidateList[0].setWidth(pixKernelSize)
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- BEGIN PSFEX
#
# Insert the good candidates into the set
#
defaultsFile = os.path.join(os.environ["MEAS_EXTENSIONS_PSFEX_DIR"], "config", "default-lsst.psfex")
args_md = dafBase.PropertySet()
args_md.set("PSFVAR_DEGREES", str(self.config.spatialOrder))
args_md.set("PSF_SIZE", str(actualKernelSize))
args_md.set("PSF_SAMPLING", str(self.config.samplingSize))
prefs = psfex.Prefs(defaultsFile, args_md)
prefs.setCommandLine([])
prefs.addCatalog("psfexPsfDeterminer")
prefs.use()
principalComponentExclusionFlag = bool(bool(psfex.Context.REMOVEHIDDEN)
if False else psfex.Context.KEEPHIDDEN)
context = psfex.Context(prefs.getContextName(), prefs.getContextGroup(),
prefs.getGroupDeg(), principalComponentExclusionFlag)
set = psfex.Set(context)
set.setVigSize(pixKernelSize, pixKernelSize)
set.setFwhm(2*np.sqrt(2*np.log(2))*np.median(sizes))
set.setRecentroid(self.config.recentroid)
catindex, ext = 0, 0
backnoise2 = afwMath.makeStatistics(mi.getImage(), afwMath.VARIANCECLIP).getValue()
ccd = exposure.getDetector()
if ccd:
gain = np.mean(np.array([a.getGain() for a in ccd]))
else:
gain = 1.0
self.log.warn("Setting gain to %g" % (gain,))
contextvalp = []
for i, key in enumerate(context.getName()):
if context.getPcflag(i):
contextvalp.append(pcval[pc])
pc += 1
elif key[0] == ':':
try:
contextvalp.append(exposure.getMetadata().get(key[1:]))
except KeyError:
raise RuntimeError("*Error*: %s parameter not found in the header of %s" %
(key[1:], prefs.getContextName()))
else:
try:
contextvalp.append(np.array([psfCandidateList[_].getSource().get(key)
for _ in range(nCand)]))
except KeyError:
raise RuntimeError("*Error*: %s parameter not found" % (key,))
set.setContextname(i, key)
if display:
frame = 0
if displayExposure:
ds9.mtv(exposure, frame=frame, title="psf determination")
badBits = mi.getMask().getPlaneBitMask(self.config.badMaskBits)
fluxName = prefs.getPhotfluxRkey()
fluxFlagName = "base_" + fluxName + "_flag"
xpos, ypos = [], []
for i, psfCandidate in enumerate(psfCandidateList):
source = psfCandidate.getSource()
xc, yc = source.getX(), source.getY()
try:
int(xc), int(yc)
except ValueError:
continue
try:
pstamp = psfCandidate.getMaskedImage().clone()
except Exception as e:
continue
if fluxFlagName in source.schema and source.get(fluxFlagName):
continue
flux = source.get(fluxName)
if flux < 0 or np.isnan(flux):
continue
# From this point, we're configuring the "sample" (PSFEx's version of a PSF candidate).
# Having created the sample, we must proceed to configure it, and then fini (finalize),
# or it will be malformed.
try:
sample = set.newSample()
sample.setCatindex(catindex)
sample.setExtindex(ext)
sample.setObjindex(i)
imArray = pstamp.getImage().getArray()
imArray[np.where(np.bitwise_and(pstamp.getMask().getArray(), badBits))] = \
-2*psfex.cvar.BIG
sample.setVig(imArray)
sample.setNorm(flux)
sample.setBacknoise2(backnoise2)
sample.setGain(gain)
sample.setX(xc)
sample.setY(yc)
sample.setFluxrad(sizes[i])
for j in range(set.getNcontext()):
sample.setContext(j, float(contextvalp[j][i]))
except Exception as e:
self.log.debug("Exception when processing sample at (%f,%f): %s", xc, yc, e)
continue
else:
set.finiSample(sample)
xpos.append(xc) # for QA
ypos.append(yc)
if displayExposure:
with ds9.Buffering():
ds9.dot("o", xc, yc, ctype=ds9.CYAN, size=4, frame=frame)
if set.getNsample() == 0:
raise RuntimeError("No good PSF candidates to pass to PSFEx")
#---- Update min and max and then the scaling
for i in range(set.getNcontext()):
cmin = contextvalp[i].min()
cmax = contextvalp[i].max()
set.setContextScale(i, cmax - cmin)
set.setContextOffset(i, (cmin + cmax)/2.0)
# Don't waste memory!
set.trimMemory()
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- END PSFEX
#
# Do a PSFEX decomposition of those PSF candidates
#
fields = psfex.vectorField()
field = psfex.Field("Unknown")
field.addExt(exposure.getWcs(), exposure.getWidth(), exposure.getHeight(), set.getNsample())
field.finalize()
fields.append(field)
sets = psfex.vectorSet()
sets.append(set)
psfex.makeit(fields, sets)
psfs = field.getPsfs()
# Flag which objects were actually used in psfex by
good_indices = []
for i in range(sets[0].getNsample()):
index = sets[0].getSample(i).getObjindex()
if index > -1:
good_indices.append(index)
if flagKey is not None:
for i, psfCandidate in enumerate(psfCandidateList):
source = psfCandidate.getSource()
if i in good_indices:
source.set(flagKey, True)
xpos = np.array(xpos)
ypos = np.array(ypos)
numGoodStars = len(good_indices)
avgX, avgY = np.mean(xpos), np.mean(ypos)
psf = psfex.PsfexPsf(psfs[0], afwGeom.Point2D(avgX, avgY))
if False and (displayResiduals or displayPsfMosaic):
ext = 0
frame = 1
diagnostics = True
catDir = "."
title = "psfexPsfDeterminer"
psfex.psfex.showPsf(psfs, set, ext,
[(exposure.getWcs(), exposure.getWidth(), exposure.getHeight())],
nspot=3, trim=5, frame=frame, diagnostics=diagnostics, outDir=catDir,
title=title)
#
# Display code for debugging
#
if display:
assert psfCellSet is not None
if displayExposure:
maUtils.showPsfSpatialCells(exposure, psfCellSet, showChi2=True,
symb="o", ctype=ds9.YELLOW, ctypeBad=ds9.RED, size=8, frame=frame)
if displayResiduals:
maUtils.showPsfCandidates(exposure, psfCellSet, psf=psf, frame=4,
normalize=normalizeResiduals,
showBadCandidates=showBadCandidates)
if displayPsfComponents:
maUtils.showPsf(psf, frame=6)
if displayPsfMosaic:
maUtils.showPsfMosaic(exposure, psf, frame=7, showFwhm=True)
ds9.scale('linear', 0, 1, frame=7)
#
# Generate some QA information
#
# Count PSF stars
#
if metadata is not None:
metadata.set("spatialFitChi2", np.nan)
metadata.set("numAvailStars", nCand)
metadata.set("numGoodStars", numGoodStars)
metadata.set("avgX", avgX)
metadata.set("avgY", avgY)
psfCellSet = None
return psf, psfCellSet
