def cosmicray(exp, config, display=False):
bg = 0.0 # We background-subtracted, right?
crList = measAlg.findCosmicRays(exp.getMaskedImage(), exp.getPsf(), bg, makePolicy(config), True)
if crList is None:
print "No CRs found"
return
mask = exp.getMaskedImage().getMask()
crBit = mask.getPlaneBitMask("CR")
afwDet.setMaskFromFootprintList(mask, crList, crBit)
num = len(crList)
print "Found %d CRs" % num
if display:
frame = 2
import lsst.afw.display.ds9 as ds9
import lsst.afw.display.utils as displayUtils
ds9.mtv(exp, title="Exposure with CRs")
with ds9.Buffering():
for cr in crList:
displayUtils.drawBBox(cr.getBBox(), borderWidth=0.55)
def cr(infn, crfn, maskfn):
exposure = afwImage.ExposureF(infn) #'850994p-21.fits'
print 'exposure', exposure
print 'w,h', exposure.getWidth(), exposure.getHeight()
W, H = exposure.getWidth(), exposure.getHeight()
#var = exposure.getMaskedImage().getVariance()
#print 'Variance', var.get(0,0)
wcs = exposure.getWcs()
print 'wcs', wcs
pixscale = wcs.pixelScale().asArcseconds()
psf = getFakePsf(pixscale)
# CRs
mask = exposure.getMaskedImage().getMask()
crBit = mask.getMaskPlane("CR")
mask.clearMaskPlane(crBit)
mi = exposure.getMaskedImage()
bg = afwMath.makeStatistics(mi, afwMath.MEDIAN).getValue()
print 'bg', bg
varval = afwMath.makeStatistics(mi, afwMath.VARIANCE).getValue()
print 'variance', varval, 'std', math.sqrt(varval)
varval = afwMath.makeStatistics(mi, afwMath.VARIANCECLIP).getValue()
print 'clipped variance', varval, 'std', math.sqrt(varval)
var = exposure.getMaskedImage().getVariance()
var.set(varval)
var = exposure.getMaskedImage().getVariance()
print 'Variance:', var.get(0, 0)
keepCRs = False
policy = pexPolicy.Policy()
# policy.add('minSigma', 6.)
# policy.add('min_DN', 150.)
# policy.add('cond3_fac', 2.5)
# policy.add('cond3_fac2', 0.6)
# policy.add('niteration', 3)
# policy.add('nCrPixelMax', 200000)
policy.add('minSigma', 10.)
policy.add('min_DN', 500.)
policy.add('cond3_fac', 2.5)
policy.add('cond3_fac2', 0.6)
policy.add('niteration', 1)
policy.add('nCrPixelMax', 100000)
#psfimg = psf.computeImage(afwGeom.Point2D(W/2., H/2.))
#psfimg.writeFits('psf.fits')
print 'Finding cosmics...'
crs = measAlg.findCosmicRays(mi, psf, bg, policy, keepCRs)
print 'got', len(crs), 'cosmic rays',
mask = mi.getMask()
crBit = mask.getPlaneBitMask("CR")
afwDet.setMaskFromFootprintList(mask, crs, crBit)
mask.writeFits(maskfn)
exposure.writeFits(crfn)
def cr(infn, crfn, maskfn):
exposure = afwImage.ExposureF(infn) #'850994p-21.fits'
print 'exposure', exposure
print 'w,h', exposure.getWidth(), exposure.getHeight()
W,H = exposure.getWidth(), exposure.getHeight()
#var = exposure.getMaskedImage().getVariance()
#print 'Variance', var.get(0,0)
wcs = exposure.getWcs()
print 'wcs', wcs
pixscale = wcs.pixelScale().asArcseconds()
psf = getFakePsf(pixscale)
# CRs
mask = exposure.getMaskedImage().getMask()
crBit = mask.getMaskPlane("CR")
mask.clearMaskPlane(crBit)
mi = exposure.getMaskedImage()
bg = afwMath.makeStatistics(mi, afwMath.MEDIAN).getValue()
print 'bg', bg
varval = afwMath.makeStatistics(mi, afwMath.VARIANCE).getValue()
print 'variance', varval, 'std', math.sqrt(varval)
varval = afwMath.makeStatistics(mi, afwMath.VARIANCECLIP).getValue()
print 'clipped variance', varval, 'std', math.sqrt(varval)
var = exposure.getMaskedImage().getVariance()
var.set(varval)
var = exposure.getMaskedImage().getVariance()
print 'Variance:', var.get(0,0)
keepCRs = False
policy = pexPolicy.Policy()
# policy.add('minSigma', 6.)
# policy.add('min_DN', 150.)
# policy.add('cond3_fac', 2.5)
# policy.add('cond3_fac2', 0.6)
# policy.add('niteration', 3)
# policy.add('nCrPixelMax', 200000)
policy.add('minSigma', 10.)
policy.add('min_DN', 500.)
policy.add('cond3_fac', 2.5)
policy.add('cond3_fac2', 0.6)
policy.add('niteration', 1)
policy.add('nCrPixelMax', 100000)
#psfimg = psf.computeImage(afwGeom.Point2D(W/2., H/2.))
#psfimg.writeFits('psf.fits')
print 'Finding cosmics...'
crs = measAlg.findCosmicRays(mi, psf, bg, policy, keepCRs)
print 'got', len(crs), 'cosmic rays',
mask = mi.getMask()
crBit = mask.getPlaneBitMask("CR")
afwDet.setMaskFromFootprintList(mask, crs, crBit)
mask.writeFits(maskfn)
exposure.writeFits(crfn)
def cosmicRay(self, exposure, keepCRs=None):
"""Mask cosmic rays
\param[in,out] exposure Exposure to process
\param[in] keepCRs Don't interpolate over the CR pixels (defer to pex_config if None)
"""
import lsstDebug
display = lsstDebug.Info(__name__).display
displayCR = lsstDebug.Info(__name__).displayCR
assert exposure, "No exposure provided"
psf = exposure.getPsf()
assert psf, "No psf provided"
# Blow away old mask
try:
mask = exposure.getMaskedImage().getMask()
crBit = mask.getMaskPlane("CR")
mask.clearMaskPlane(crBit)
except Exception:
pass
mi = exposure.getMaskedImage()
bg = afwMath.makeStatistics(mi, afwMath.MEDIAN).getValue()
if keepCRs is None:
keepCRs = self.config.cosmicray.keepCRs
try:
crs = measAlg.findCosmicRays(mi, psf, bg, pexConfig.makePolicy(self.config.cosmicray), keepCRs)
except Exception:
if display:
import lsst.afw.display.ds9 as ds9
ds9.mtv(exposure, title="Failed CR")
raise
num = 0
if crs is not None:
mask = mi.getMask()
crBit = mask.getPlaneBitMask("CR")
afwDet.setMaskFromFootprintList(mask, crs, crBit)
num = len(crs)
if display and displayCR:
import lsst.afw.display.ds9 as ds9
import lsst.afw.display.utils as displayUtils
ds9.incrDefaultFrame()
ds9.mtv(exposure, title="Post-CR")
with ds9.Buffering():
for cr in crs:
displayUtils.drawBBox(cr.getBBox(), borderWidth=0.55)
self.log.info("Identified %s cosmic rays." % (num,))
def cosmicRay(self, exposure, keepCRs=None):
"""Mask cosmic rays
@param[in,out] exposure Exposure to process
@param keepCRs Don't interpolate over the CR pixels (defer to pex_config if None)
"""
import lsstDebug
display = lsstDebug.Info(__name__).display
displayCR = lsstDebug.Info(__name__).displayCR
assert exposure, "No exposure provided"
psf = exposure.getPsf()
assert psf, "No psf provided"
# Blow away old mask
try:
mask = exposure.getMaskedImage().getMask()
crBit = mask.getMaskPlane("CR")
mask.clearMaskPlane(crBit)
except Exception:
pass
exposure0 = exposure # initial value of exposure
binSize = self.config.cosmicray.background.binSize
nx, ny = exposure.getWidth()/binSize, exposure.getHeight()/binSize
if nx*ny <= 1:
bg = afwMath.makeStatistics(exposure.getMaskedImage(), afwMath.MEDIAN).getValue()
bkgd = None
else:
exposure = exposure.Factory(exposure, True)
bkgd, exposure = measAlg.estimateBackground(exposure, self.config.cosmicray.background,
subtract=True)
bg = 0.0
if keepCRs is None:
keepCRs = self.config.cosmicray.keepCRs
try:
crs = measAlg.findCosmicRays(exposure.getMaskedImage(),
psf, bg, pexConfig.makePolicy(self.config.cosmicray), keepCRs)
if bkgd:
# Add back background image
img = exposure.getMaskedImage().getImage()
img += bkgd.getImageF()
del img
# Replace original image with CR subtracted image
mimg = exposure0.getMaskedImage()
mimg <<= exposure.getMaskedImage()
del mimg
except Exception, e:
if display:
import lsst.afw.display.ds9 as ds9
ds9.mtv(exposure0, title="Failed CR")
raise
def cosmicray(self, exposure, psf):
"""Cosmic ray masking
@param exposure Exposure to process
@param psf PSF
"""
import lsstDebug
display = lsstDebug.Info(__name__).display
displayCR = lsstDebug.Info(__name__).displayCR
assert exposure, "No exposure provided"
assert psf, "No psf provided"
# Blow away old mask
try:
mask = exposure.getMaskedImage().getMask()
crBit = mask.getMaskPlane("CR")
mask.clearMaskPlane(crBit)
except:
pass
if display and displayCR:
ds9.incrDefaultFrame()
ds9.mtv(exposure, title="Pre-CR")
policy = self.config['cosmicray'].getPolicy()
mi = exposure.getMaskedImage()
bg = afwMath.makeStatistics(mi, afwMath.MEDIAN).getValue()
crs = measAlg.findCosmicRays(mi, psf, bg, policy, self._keepCRs)
num = 0
if crs is not None:
mask = mi.getMask()
crBit = mask.getPlaneBitMask("CR")
afwDet.setMaskFromFootprintList(mask, crs, crBit)
num = len(crs)
if display and displayCR:
ds9.incrDefaultFrame()
ds9.mtv(exposure, title="Post-CR")
ds9.cmdBuffer.pushSize()
for cr in crs:
displayUtils.drawBBox(cr.getBBox(), borderWidth=0.55)
ds9.cmdBuffer.popSize()
self.log.log(self.log.INFO, "Identified %d cosmic rays." % num)
return
def cosmicray(exp, config, display=False):
bg = 0.0 # We background-subtracted, right?
crList = measAlg.findCosmicRays(exp.getMaskedImage(), exp.getPsf(), bg, makePolicy(config), True)
if crList is None:
print "No CRs found"
return
mask = exp.getMaskedImage().getMask()
crBit = mask.getPlaneBitMask("CR")
afwDet.setMaskFromFootprintList(mask, crList, crBit)
num = len(crList)
print "Found %d CRs" % num
if display:
frame = 2
def findCosmicRays(exposure, crRejectPolicy, defaultFwhm, keepCRs):
"""defaultFwhm is in arcsec"""
mi = exposure.getMaskedImage()
wcs = exposure.getWcs()
scale = wcs.pixelScale().asArcseconds()
defaultFwhm /= scale # convert to pixels
ksize = 4 * int(defaultFwhm) + 1
psf = afwDetection.createPsf(
'DoubleGaussian', ksize, ksize,
defaultFwhm / (2 * math.sqrt(2 * math.log(2))))
bg = afwMath.makeStatistics(mi, afwMath.MEDIAN).getValue()
crs = measAlg.findCosmicRays(mi, psf, bg, crRejectPolicy, keepCRs)
return crs
def ISR(self, fixCRs = True):
"""Run the ISR stage, removing CRs and patching bad columns"""
mi = self.exposure.getMaskedImage()
mi.getMask().set(0) # XXX
#
# Fix defects
#
# Mask known bad pixels
#
badPixels = measAlg.defects.policyToBadRegionList(os.path.join(eups.productDir("meas_algorithms"),
"examples", "BadPixels.paf"))
# did someone lie about the origin of the maskedImage? If so, adjust bad pixel list
if self.XY0.getX() != mi.getX0() or self.XY0.getY() != mi.getY0():
dx = self.XY0.getX() - mi.getX0()
dy = self.XY0.getY() - mi.getY0()
for bp in badPixels:
bp.shift(-dx, -dy)
measAlg.interpolateOverDefects(mi, self.psf, badPixels)
#
# Subtract background
#
bctrl = afwMath.BackgroundControl("LINEAR");
bctrl.setNxSample(int(mi.getWidth()/256) + 1);
bctrl.setNySample(int(mi.getHeight()/256) + 1);
backobj = afwMath.makeBackground(mi.getImage(), bctrl)
img = mi.getImage(); img -= backobj.getImageF(); del img
#
# Remove CRs
#
if fixCRs:
crConfig = measAlg.FindCosmicRaysConfig()
crs = measAlg.findCosmicRays(mi, self.psf, 0, pexConfig.makePolicy(crConfig))
if self.display:
ds9.mtv(mi, frame = 0, lowOrderBits = True)
def testDetection(self):
crConfig = algorithms.FindCosmicRaysConfig()
crs = algorithms.findCosmicRays(self.mi, self.psf, 0.0, pexConfig.makePolicy(crConfig))
self.assertEqual(len(crs), 0, "Found %d CRs in empty image" % len(crs))
def testDetection(self):
"""Test CR detection."""
#
# Subtract background
#
bctrl = afwMath.BackgroundControl(afwMath.Interpolate.NATURAL_SPLINE)
bctrl.setNxSample(int(self.mi.getWidth() / 256) + 1)
bctrl.setNySample(int(self.mi.getHeight() / 256) + 1)
bctrl.getStatisticsControl().setNumSigmaClip(3.0)
bctrl.getStatisticsControl().setNumIter(2)
im = self.mi.getImage()
try:
backobj = afwMath.makeBackground(im, bctrl)
except Exception as e:
print(e, file=sys.stderr)
bctrl.setInterpStyle(afwMath.Interpolate.CONSTANT)
backobj = afwMath.makeBackground(im, bctrl)
im -= backobj.getImageF()
if display:
frame = 0
disp = afwDisplay.Display(frame=frame)
disp.mtv(self.mi,
title=self._testMethodName + ": Raw") # raw frame
if self.mi.getWidth() > 256:
disp.pan(944 - self.mi.getX0(), 260 - self.mi.getY0())
#
# Mask known bad pixels
#
badPixels = testUtils.makeDefectList()
algorithms.interpolateOverDefects(self.mi, self.psf, badPixels)
stats = afwMath.makeStatistics(self.mi.getImage(),
afwMath.MEANCLIP | afwMath.STDEVCLIP)
background = stats.getValue(afwMath.MEANCLIP)
crConfig = algorithms.FindCosmicRaysConfig()
crs = algorithms.findCosmicRays(self.mi, self.psf, background,
pexConfig.makePropertySet(crConfig))
if display:
frame += 1
disp = afwDisplay.Display(frame=frame)
disp.mtv(self.mi, title=self._testMethodName + ": CRs removed")
if self.mi.getWidth() > 256:
disp.pan(944 - self.mi.getX0(), 260 - self.mi.getY0())
print("Detected %d CRs" % len(crs))
if display and False:
for cr in crs:
bbox = cr.getBBox()
bbox.shift(
lsst.geom.ExtentI(-self.mi.getX0(), -self.mi.getY0()))
disp.line([(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5),
(bbox.getMaxX() + 0.5, bbox.getMinY() - 0.5),
(bbox.getMaxX() + 0.5, bbox.getMaxY() + 0.5),
(bbox.getMinX() - 0.5, bbox.getMaxY() + 0.5),
(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5)])
if self.nCR is not None:
self.assertEqual(len(crs), self.nCR)
def cosmicRay(self, exposure, keepCRs=None):
"""Mask cosmic rays
@param[in,out] exposure Exposure to process
@param[in] keepCRs Don't interpolate over the CR pixels (defer to pex_config if None)
"""
import lsstDebug
display = lsstDebug.Info(__name__).display
displayCR = lsstDebug.Info(__name__).displayCR
assert exposure, "No exposure provided"
psf = exposure.getPsf()
assert psf, "No psf provided"
# Blow away old mask
try:
mask = exposure.getMaskedImage().getMask()
crBit = mask.getMaskPlane("CR")
mask.clearMaskPlane(crBit)
except Exception:
pass
exposure0 = exposure # initial value of exposure
binSize = self.config.cosmicray.background.binSize
nx, ny = exposure.getWidth()/binSize, exposure.getHeight()/binSize
# Treat constant background as a special case to avoid the extra complexity in calling
# measAlg.SubtractBackgroundTask().
if nx*ny <= 1:
medianBg = afwMath.makeStatistics(exposure.getMaskedImage(), afwMath.MEDIAN).getValue()
modelBg = None
else:
# make a deep copy of the exposure before subtracting its background,
# because this routine is only allowed to modify the exposure by setting mask planes
# and interpolating over defects, not changing the background level
exposure = exposure.Factory(exposure, True)
subtractBackgroundTask = measAlg.SubtractBackgroundTask(config=self.config.cosmicray.background)
modelBg = subtractBackgroundTask.run(exposure).background
medianBg = 0.0
if keepCRs is None:
keepCRs = self.config.cosmicray.keepCRs
try:
crs = measAlg.findCosmicRays(exposure.getMaskedImage(), psf, medianBg,
pexConfig.makePropertySet(self.config.cosmicray), keepCRs)
if modelBg:
# Add back background image
img = exposure.getMaskedImage()
img += modelBg.getImageF()
del img
# Replace original image with CR subtracted image
exposure0.setMaskedImage(exposure.getMaskedImage())
except Exception:
if display:
afwDisplay.Display().mtv(exposure0, title="Failed CR")
raise
num = 0
if crs is not None:
mask = exposure0.getMaskedImage().getMask()
crBit = mask.getPlaneBitMask("CR")
afwDet.setMaskFromFootprintList(mask, crs, crBit)
num = len(crs)
if display and displayCR:
disp = afwDisplay.Display()
disp.incrDefaultFrame()
disp.mtv(exposure0, title="Post-CR")
with disp.Buffering():
for cr in crs:
afwDisplay.utils.drawBBox(cr.getBBox(), borderWidth=0.55)
self.log.info("Identified %s cosmic rays.", num)
def testDetection(self):
"""Test object detection"""
#
# Fix defects
#
# Mask known bad pixels
#
measAlgorithmsDir = lsst.utils.getPackageDir('meas_algorithms')
badPixels = defects.policyToBadRegionList(os.path.join(measAlgorithmsDir,
"policy/BadPixels.paf"))
# did someone lie about the origin of the maskedImage? If so, adjust bad pixel list
if self.XY0.getX() != self.mi.getX0() or self.XY0.getY() != self.mi.getY0():
dx = self.XY0.getX() - self.mi.getX0()
dy = self.XY0.getY() - self.mi.getY0()
for bp in badPixels:
bp.shift(-dx, -dy)
algorithms.interpolateOverDefects(self.mi, self.psf, badPixels)
#
# Subtract background
#
bgGridSize = 64 # was 256 ... but that gives only one region and the spline breaks
bctrl = afwMath.BackgroundControl(afwMath.Interpolate.NATURAL_SPLINE)
bctrl.setNxSample(int(self.mi.getWidth()/bgGridSize) + 1)
bctrl.setNySample(int(self.mi.getHeight()/bgGridSize) + 1)
backobj = afwMath.makeBackground(self.mi.getImage(), bctrl)
self.mi.getImage()[:] -= backobj.getImageF()
#
# Remove CRs
#
crConfig = algorithms.FindCosmicRaysConfig()
algorithms.findCosmicRays(self.mi, self.psf, 0, pexConfig.makePolicy(crConfig))
#
# We do a pretty good job of interpolating, so don't propagagate the convolved CR/INTRP bits
# (we'll keep them for the original CR/INTRP pixels)
#
savedMask = self.mi.getMask().Factory(self.mi.getMask(), True)
saveBits = savedMask.getPlaneBitMask("CR") | \
savedMask.getPlaneBitMask("BAD") | \
savedMask.getPlaneBitMask("INTRP") # Bits to not convolve
savedMask &= saveBits
msk = self.mi.getMask()
msk &= ~saveBits # Clear the saved bits
del msk
#
# Smooth image
#
psf = algorithms.DoubleGaussianPsf(15, 15, self.FWHM/(2*math.sqrt(2*math.log(2))))
cnvImage = self.mi.Factory(self.mi.getBBox())
kernel = psf.getKernel()
afwMath.convolve(cnvImage, self.mi, kernel, afwMath.ConvolutionControl())
msk = cnvImage.getMask()
msk |= savedMask # restore the saved bits
del msk
threshold = afwDetection.Threshold(3, afwDetection.Threshold.STDEV)
#
# Only search the part of the frame that was PSF-smoothed
#
llc = lsst.geom.PointI(psf.getKernel().getWidth()//2, psf.getKernel().getHeight()//2)
urc = lsst.geom.PointI(cnvImage.getWidth() - llc[0] - 1, cnvImage.getHeight() - llc[1] - 1)
middle = cnvImage.Factory(cnvImage, lsst.geom.BoxI(llc, urc), afwImage.LOCAL)
ds = afwDetection.FootprintSet(middle, threshold, "DETECTED")
del middle
#
# Reinstate the saved (e.g. BAD) (and also the DETECTED | EDGE) bits in the unsmoothed image
#
savedMask[:] = cnvImage.getMask()
msk = self.mi.getMask()
msk |= savedMask
del msk
del savedMask
if display:
disp = afwDisplay.Display(frame=2)
disp.mtv(self.mi, title=self._testMethodName + ": image")
afwDisplay.Display(frame=3).mtv(cnvImage, title=self._testMethodName + ": cnvImage")
#
# Time to actually measure
#
schema = afwTable.SourceTable.makeMinimalSchema()
sfm_config = measBase.SingleFrameMeasurementConfig()
sfm_config.plugins = ["base_SdssCentroid", "base_CircularApertureFlux", "base_PsfFlux",
"base_SdssShape", "base_GaussianFlux",
"base_PixelFlags"]
sfm_config.slots.centroid = "base_SdssCentroid"
sfm_config.slots.shape = "base_SdssShape"
sfm_config.slots.psfFlux = "base_PsfFlux"
sfm_config.slots.gaussianFlux = None
sfm_config.slots.apFlux = "base_CircularApertureFlux_3_0"
sfm_config.slots.modelFlux = "base_GaussianFlux"
sfm_config.slots.calibFlux = None
sfm_config.plugins["base_SdssShape"].maxShift = 10.0
sfm_config.plugins["base_CircularApertureFlux"].radii = [3.0]
task = measBase.SingleFrameMeasurementTask(schema, config=sfm_config)
measCat = afwTable.SourceCatalog(schema)
# detect the sources and run with the measurement task
ds.makeSources(measCat)
self.exposure.setPsf(self.psf)
task.run(measCat, self.exposure)
self.assertGreater(len(measCat), 0)
for source in measCat:
if source.get("base_PixelFlags_flag_edge"):
continue
if display:
disp.dot("+", source.getX(), source.getY())
def cosmicRay(self, exposure, keepCRs=None):
"""Mask cosmic rays
\param[in,out] exposure Exposure to process
\param[in] keepCRs Don't interpolate over the CR pixels (defer to pex_config if None)
"""
import lsstDebug
display = lsstDebug.Info(__name__).display
displayCR = lsstDebug.Info(__name__).displayCR
assert exposure, "No exposure provided"
psf = exposure.getPsf()
assert psf, "No psf provided"
# Blow away old mask
try:
mask = exposure.getMaskedImage().getMask()
crBit = mask.getMaskPlane("CR")
mask.clearMaskPlane(crBit)
except Exception:
pass
exposure0 = exposure # initial value of exposure
binSize = self.config.cosmicray.background.binSize
nx, ny = exposure.getWidth()/binSize, exposure.getHeight()/binSize
# Treat constant background as a special case to avoid the extra complexity in calling
# measAlg.SubtractBackgroundTask().
if nx*ny <= 1:
medianBg = afwMath.makeStatistics(exposure.getMaskedImage(), afwMath.MEDIAN).getValue()
modelBg = None
else:
# make a deep copy of the exposure before subtracting its background,
# because this routine is only allowed to modify the exposure by setting mask planes
# and interpolating over defects, not changing the background level
exposure = exposure.Factory(exposure, True)
subtractBackgroundTask = measAlg.SubtractBackgroundTask(config=self.config.cosmicray.background)
modelBg = subtractBackgroundTask.run(exposure).background
medianBg = 0.0
if keepCRs is None:
keepCRs = self.config.cosmicray.keepCRs
try:
crs = measAlg.findCosmicRays(exposure.getMaskedImage(), psf, medianBg,
pexConfig.makePolicy(self.config.cosmicray), keepCRs)
if modelBg:
# Add back background image
img = exposure.getMaskedImage()
img += modelBg.getImageF()
del img
# Replace original image with CR subtracted image
exposure0.setMaskedImage(exposure.getMaskedImage())
except Exception:
if display:
import lsst.afw.display.ds9 as ds9
ds9.mtv(exposure0, title="Failed CR")
raise
num = 0
if crs is not None:
mask = exposure0.getMaskedImage().getMask()
crBit = mask.getPlaneBitMask("CR")
afwDet.setMaskFromFootprintList(mask, crs, crBit)
num = len(crs)
if display and displayCR:
import lsst.afw.display.ds9 as ds9
import lsst.afw.display.utils as displayUtils
ds9.incrDefaultFrame()
ds9.mtv(exposure0, title="Post-CR")
with ds9.Buffering():
for cr in crs:
displayUtils.drawBBox(cr.getBBox(), borderWidth=0.55)
self.log.info("Identified %s cosmic rays." % (num,))
class CosmicRayTestCase(unittest.TestCase):
"""A test case for Cosmic Ray detection"""
def setUp(self):
self.FWHM = 5 # pixels
self.psf = algorithms.DoubleGaussianPsf(
29, 29, self.FWHM / (2 * sqrt(2 * log(2))))
self.mi = afwImage.MaskedImageF(imageFile)
self.XY0 = afwGeom.PointI(0, 0) # origin of the subimage we use
if imageFile == imageFile0:
if True: # use full image, trimmed to data section
self.XY0 = afwGeom.PointI(32, 2)
self.mi = self.mi.Factory(
self.mi, afwGeom.BoxI(self.XY0, afwGeom.PointI(2079,
4609)),
afwImage.LOCAL)
self.mi.setXY0(afwGeom.PointI(0, 0))
self.nCR = 1076 # number of CRs we should detect
else: # use sub-image
if True:
self.XY0 = afwGeom.PointI(824, 140)
self.nCR = 10
else:
self.XY0 = afwGeom.PointI(280, 2750)
self.nCR = 2
self.mi = self.mi.Factory(
self.mi,
afwGeom.BoxI(self.XY0, afwGeom.ExtentI(256, 256),
afwImage.LOCAL))
self.mi.setXY0(afwGeom.PointI(0, 0))
else:
self.nCR = None
self.mi.getMask().addMaskPlane("DETECTED")
def tearDown(self):
del self.mi
del self.psf
def testDetection(self):
"""Test CR detection"""
#
# Subtract background
#
bctrl = afwMath.BackgroundControl(afwMath.Interpolate.NATURAL_SPLINE)
bctrl.setNxSample(int(self.mi.getWidth() / 256) + 1)
bctrl.setNySample(int(self.mi.getHeight() / 256) + 1)
bctrl.getStatisticsControl().setNumSigmaClip(3.0)
bctrl.getStatisticsControl().setNumIter(2)
im = self.mi.getImage()
try:
backobj = afwMath.makeBackground(im, bctrl)
except Exception, e:
print >> sys.stderr, e,
bctrl.setInterpStyle(afwMath.Interpolate.CONSTANT)
backobj = afwMath.makeBackground(im, bctrl)
im -= backobj.getImageF()
if display:
frame = 0
ds9.mtv(self.mi, frame=frame, title="Raw") # raw frame
if self.mi.getWidth() > 256:
ds9.pan(944 - self.mi.getX0(), 260 - self.mi.getY0())
#
# Mask known bad pixels
#
badPixels = defects.policyToBadRegionList(
os.path.join(os.environ["MEAS_ALGORITHMS_DIR"], "policy",
"BadPixels.paf"))
# did someone lie about the origin of the maskedImage? If so, adjust bad pixel list
if self.XY0.getX() != self.mi.getX0() or self.XY0.getY(
) != self.mi.getY0():
dx = self.XY0.getX() - self.mi.getX0()
dy = self.XY0.getY() - self.mi.getY0()
for bp in badPixels:
bp.shift(-dx, -dy)
algorithms.interpolateOverDefects(self.mi, self.psf, badPixels)
stats = afwMath.makeStatistics(self.mi.getImage(),
afwMath.MEANCLIP | afwMath.STDEVCLIP)
background = stats.getValue(afwMath.MEANCLIP)
crConfig = algorithms.FindCosmicRaysConfig()
crs = algorithms.findCosmicRays(self.mi, self.psf, background,
pexConfig.makePolicy(crConfig))
if display:
ds9.mtv(self.mi, frame=frame + 1, title="CRs removed")
if self.mi.getWidth() > 256:
ds9.pan(944 - self.mi.getX0(), 260 - self.mi.getY0())
print "Detected %d CRs" % len(crs)
if display and False:
for cr in crs:
bbox = cr.getBBox()
bbox.shift(afwGeom.ExtentI(-self.mi.getX0(), -self.mi.getY0()))
ds9.line([(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5),
(bbox.getMaxX() + 0.5, bbox.getMinY() - 0.5),
(bbox.getMaxX() + 0.5, bbox.getMaxY() + 0.5),
(bbox.getMinX() - 0.5, bbox.getMaxY() + 0.5),
(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5)],
frame=frame + 1)
if self.nCR is not None:
self.assertEqual(len(crs), self.nCR)
def testDetection(self):
crConfig = algorithms.FindCosmicRaysConfig()
crs = algorithms.findCosmicRays(self.mi, self.psf, 0.0,
pexConfig.makePolicy(crConfig))
self.assertEqual(len(crs), 0, "Found %d CRs in empty image" % len(crs))
def testDetection(self):
"""Test object detection"""
#
# Fix defects
#
# Mask known bad pixels
#
badPixels = defects.policyToBadRegionList(os.path.join(eups.productDir("meas_algorithms"),
"policy/BadPixels.paf"))
# did someone lie about the origin of the maskedImage? If so, adjust bad pixel list
if self.XY0.getX() != self.mi.getX0() or self.XY0.getY() != self.mi.getY0():
dx = self.XY0.getX() - self.mi.getX0()
dy = self.XY0.getY() - self.mi.getY0()
for bp in badPixels:
bp.shift(-dx, -dy)
algorithms.interpolateOverDefects(self.mi, self.psf, badPixels)
#
# Subtract background
#
bgGridSize = 64 # was 256 ... but that gives only one region and the spline breaks
bctrl = afwMath.BackgroundControl(afwMath.Interpolate.NATURAL_SPLINE);
bctrl.setNxSample(int(self.mi.getWidth()/bgGridSize) + 1);
bctrl.setNySample(int(self.mi.getHeight()/bgGridSize) + 1);
backobj = afwMath.makeBackground(self.mi.getImage(), bctrl)
img = self.mi.getImage(); img -= backobj.getImageF(); del img
#
# Remove CRs
#
crConfig = algorithms.FindCosmicRaysConfig()
crs = algorithms.findCosmicRays(self.mi, self.psf, 0, pexConfig.makePolicy(crConfig))
#
# We do a pretty good job of interpolating, so don't propagagate the convolved CR/INTRP bits
# (we'll keep them for the original CR/INTRP pixels)
#
savedMask = self.mi.getMask().Factory(self.mi.getMask(), True)
saveBits = savedMask.getPlaneBitMask("CR") | \
savedMask.getPlaneBitMask("BAD") | \
savedMask.getPlaneBitMask("INTRP") # Bits to not convolve
savedMask &= saveBits
msk = self.mi.getMask(); msk &= ~saveBits; del msk # Clear the saved bits
#
# Smooth image
#
FWHM = 5
psf = algorithms.DoubleGaussianPsf(15, 15, self.FWHM/(2*sqrt(2*log(2))))
cnvImage = self.mi.Factory(self.mi.getBBox(afwImage.PARENT))
kernel = psf.getKernel()
afwMath.convolve(cnvImage, self.mi, kernel, afwMath.ConvolutionControl())
msk = cnvImage.getMask(); msk |= savedMask; del msk # restore the saved bits
threshold = afwDetection.Threshold(3, afwDetection.Threshold.STDEV)
#
# Only search the part of the frame that was PSF-smoothed
#
llc = afwGeom.PointI(psf.getKernel().getWidth()/2, psf.getKernel().getHeight()/2)
urc = afwGeom.PointI(cnvImage.getWidth() -llc[0] - 1, cnvImage.getHeight() - llc[1] - 1)
middle = cnvImage.Factory(cnvImage, afwGeom.BoxI(llc, urc), afwImage.LOCAL)
ds = afwDetection.FootprintSet(middle, threshold, "DETECTED")
del middle
#
# Reinstate the saved (e.g. BAD) (and also the DETECTED | EDGE) bits in the unsmoothed image
#
savedMask <<= cnvImage.getMask()
msk = self.mi.getMask(); msk |= savedMask; del msk
del savedMask
if display:
ds9.mtv(self.mi, frame = 0)
ds9.mtv(cnvImage, frame = 1)
#
# Time to actually measure
#
measureSourcesConfig = algorithms.SourceMeasurementConfig()
measureSourcesConfig.load("tests/config/MeasureSources.py")
schema = afwTable.SourceTable.makeMinimalSchema()
ms = measureSourcesConfig.makeMeasureSources(schema)
catalog = afwTable.SourceCatalog(schema)
measureSourcesConfig.slots.calibFlux = None
measureSourcesConfig.slots.setupTable(catalog.table)
ds.makeSources(catalog)
for source in catalog:
# NOTE: this was effectively failing on master, because an exception was being squashed
ms.applyWithPeak(source, self.exposure)
if source.get("flags.pixel.edge"):
continue
if display:
ds9.dot("+", source.getX() - self.mi.getX0(), source.getY() - self.mi.getY0())
def testDetection(self):
"""Test CR detection."""
#
# Subtract background
#
bctrl = afwMath.BackgroundControl(afwMath.Interpolate.NATURAL_SPLINE)
bctrl.setNxSample(int(self.mi.getWidth() / 256) + 1)
bctrl.setNySample(int(self.mi.getHeight() / 256) + 1)
bctrl.getStatisticsControl().setNumSigmaClip(3.0)
bctrl.getStatisticsControl().setNumIter(2)
im = self.mi.getImage()
try:
backobj = afwMath.makeBackground(im, bctrl)
except Exception as e:
print(e, file=sys.stderr)
bctrl.setInterpStyle(afwMath.Interpolate.CONSTANT)
backobj = afwMath.makeBackground(im, bctrl)
im -= backobj.getImageF()
if display:
frame = 0
disp = afwDisplay.Display(frame=frame)
disp.mtv(self.mi,
title=self._testMethodName + ": Raw") # raw frame
if self.mi.getWidth() > 256:
disp.pan(944 - self.mi.getX0(), 260 - self.mi.getY0())
#
# Mask known bad pixels
#
measAlgorithmsDir = lsst.utils.getPackageDir('meas_algorithms')
badPixels = defects.policyToBadRegionList(
os.path.join(measAlgorithmsDir, "policy", "BadPixels.paf"))
# did someone lie about the origin of the maskedImage? If so, adjust bad pixel list
if self.XY0.getX() != self.mi.getX0() or self.XY0.getY(
) != self.mi.getY0():
dx = self.XY0.getX() - self.mi.getX0()
dy = self.XY0.getY() - self.mi.getY0()
for bp in badPixels:
bp.shift(-dx, -dy)
algorithms.interpolateOverDefects(self.mi, self.psf, badPixels)
stats = afwMath.makeStatistics(self.mi.getImage(),
afwMath.MEANCLIP | afwMath.STDEVCLIP)
background = stats.getValue(afwMath.MEANCLIP)
crConfig = algorithms.FindCosmicRaysConfig()
crs = algorithms.findCosmicRays(self.mi, self.psf, background,
pexConfig.makePolicy(crConfig))
if display:
frame += 1
disp = afwDisplay.Display(frame=frame)
disp.mtv(self.mi, title=self._testMethodName + ": CRs removed")
if self.mi.getWidth() > 256:
disp.pan(944 - self.mi.getX0(), 260 - self.mi.getY0())
print("Detected %d CRs" % len(crs))
if display and False:
for cr in crs:
bbox = cr.getBBox()
bbox.shift(
lsst.geom.ExtentI(-self.mi.getX0(), -self.mi.getY0()))
disp.line([(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5),
(bbox.getMaxX() + 0.5, bbox.getMinY() - 0.5),
(bbox.getMaxX() + 0.5, bbox.getMaxY() + 0.5),
(bbox.getMinX() - 0.5, bbox.getMaxY() + 0.5),
(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5)])
if self.nCR is not None:
self.assertEqual(len(crs), self.nCR)
def testDetection(self):
"""Test CR detection."""
#
# Subtract background
#
bctrl = afwMath.BackgroundControl(afwMath.Interpolate.NATURAL_SPLINE)
bctrl.setNxSample(int(self.mi.getWidth()/256) + 1)
bctrl.setNySample(int(self.mi.getHeight()/256) + 1)
bctrl.getStatisticsControl().setNumSigmaClip(3.0)
bctrl.getStatisticsControl().setNumIter(2)
im = self.mi.getImage()
try:
backobj = afwMath.makeBackground(im, bctrl)
except Exception as e:
print(e, file=sys.stderr)
bctrl.setInterpStyle(afwMath.Interpolate.CONSTANT)
backobj = afwMath.makeBackground(im, bctrl)
im -= backobj.getImageF()
if display:
frame = 0
disp = afwDisplay.Display(frame=frame)
disp.mtv(self.mi, title=self._testMethodName + ": Raw") # raw frame
if self.mi.getWidth() > 256:
disp.pan(944 - self.mi.getX0(), 260 - self.mi.getY0())
#
# Mask known bad pixels
#
measAlgorithmsDir = lsst.utils.getPackageDir('meas_algorithms')
badPixels = defects.policyToBadRegionList(os.path.join(measAlgorithmsDir,
"policy", "BadPixels.paf"))
# did someone lie about the origin of the maskedImage? If so, adjust bad pixel list
if self.XY0.getX() != self.mi.getX0() or self.XY0.getY() != self.mi.getY0():
dx = self.XY0.getX() - self.mi.getX0()
dy = self.XY0.getY() - self.mi.getY0()
for bp in badPixels:
bp.shift(-dx, -dy)
algorithms.interpolateOverDefects(self.mi, self.psf, badPixels)
stats = afwMath.makeStatistics(self.mi.getImage(), afwMath.MEANCLIP | afwMath.STDEVCLIP)
background = stats.getValue(afwMath.MEANCLIP)
crConfig = algorithms.FindCosmicRaysConfig()
crs = algorithms.findCosmicRays(self.mi, self.psf, background, pexConfig.makePolicy(crConfig))
if display:
frame += 1
disp = afwDisplay.Display(frame=frame)
disp.mtv(self.mi, title=self._testMethodName + ": CRs removed")
if self.mi.getWidth() > 256:
disp.pan(944 - self.mi.getX0(), 260 - self.mi.getY0())
print("Detected %d CRs" % len(crs))
if display and False:
for cr in crs:
bbox = cr.getBBox()
bbox.shift(lsst.geom.ExtentI(-self.mi.getX0(), -self.mi.getY0()))
disp.line([(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5),
(bbox.getMaxX() + 0.5, bbox.getMinY() - 0.5),
(bbox.getMaxX() + 0.5, bbox.getMaxY() + 0.5),
(bbox.getMinX() - 0.5, bbox.getMaxY() + 0.5),
(bbox.getMinX() - 0.5, bbox.getMinY() - 0.5)])
if self.nCR is not None:
self.assertEqual(len(crs), self.nCR)
