def testImageStatisticsNan(self, core=3):
numArray = num.zeros((20, 20))
mi = afwImage.MaskedImageF(geom.Extent2I(20, 20))
for j in range(mi.getHeight()):
for i in range(mi.getWidth()):
mi[i, j, afwImage.LOCAL] = (numArray[j][i], 0x0, 0)
# inverse variance weight of 0 is NaN
imstat = ipDiffim.ImageStatisticsF(self.ps)
imstat.apply(mi)
self.assertEqual(imstat.getNpix(), 0)
imstat = ipDiffim.ImageStatisticsF(self.ps)
imstat.apply(mi, core)
self.assertEqual(imstat.getNpix(), 0)
def setUp(self):
if not defDataDir:
return
self.configAL = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.configAL.kernel.name = "AL"
self.subconfigAL = self.configAL.kernel.active
self.configDF = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.configDF.kernel.name = "DF"
self.subconfigDF = self.configDF.kernel.active
self.configDFr = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.configDFr.kernel.name = "DF"
self.subconfigDFr = self.configDFr.kernel.active
self.subconfigDF.useRegularization = False
self.subconfigDFr.useRegularization = True
self.scienceExposure = afwImage.ExposureF(defSciencePath)
self.templateExposure = afwImage.ExposureF(defTemplatePath)
warper = afwMath.Warper.fromConfig(self.subconfigAL.warpingConfig)
self.templateExposure = warper.warpExposure(self.scienceExposure.getWcs(), self.templateExposure,
destBBox=self.scienceExposure.getBBox())
self.scienceMaskedImage = self.scienceExposure.getMaskedImage()
self.templateMaskedImage = self.templateExposure.getMaskedImage()
self.dStats = ipDiffim.ImageStatisticsF()
bgConfig = self.subconfigAL.afwBackgroundConfig
diffimTools.backgroundSubtract(bgConfig, [self.templateMaskedImage,
self.scienceMaskedImage])
def testImageStatisticsMask2(self):
# Mask value that does not get ignored
maskPlanes = self.ps.getArray("badMaskPlanes")
for maskPlane in ("BAD", "EDGE", "CR", "SAT", "INTRP"):
if maskPlane not in maskPlanes:
maskVal = afwImage.Mask.getPlaneBitMask(maskPlane)
break
self.assertGreater(maskVal, 0)
numArray = num.ones((20, 20))
mi = afwImage.MaskedImageF(geom.Extent2I(20, 20))
for j in range(mi.getHeight()):
for i in range(mi.getWidth()):
val = i + 2.3 * j
if i == 19:
mi[i, j, afwImage.LOCAL] = (val, maskVal, 1)
numArray[j][i] = val
else:
mi[i, j, afwImage.LOCAL] = (val, 0x0, 1)
numArray[j][i] = val
imstat = ipDiffim.ImageStatisticsF(self.ps)
imstat.apply(mi)
self.assertAlmostEqual(imstat.getMean(), numArray.mean())
# note that these don't agree exactly...
self.assertAlmostEqual(imstat.getRms(), numArray.std(), 1)
self.assertEqual(imstat.getNpix(), 20 * 20)
def stats(self, cid, diffim, core=5):
ps = pexConfig.makePropertySet(self.config)
dStats = ipDiffim.ImageStatisticsF(ps)
dStats.apply(diffim)
logger.debug("Candidate %d : Residuals all (%d px): %.3f +/- %.3f",
cid, dStats.getNpix(), dStats.getMean(), dStats.getRms())
dStats.apply(diffim, core)
logger.debug("Candidate %d : Residuals core (%d px): %.3f +/- %.3f",
cid, dStats.getNpix(), dStats.getMean(), dStats.getRms())
def testImageStatisticsCore(self, core=3):
numArray = num.ones((20, 20))
mi = afwImage.MaskedImageF(geom.Extent2I(20, 20))
for j in range(mi.getHeight()):
for i in range(mi.getWidth()):
mi[i, j, afwImage.LOCAL] = (numArray[j][i], 0x0, 1)
imstat = ipDiffim.ImageStatisticsF(self.ps)
imstat.apply(mi, core)
self.assertEqual(imstat.getMean(), 1)
self.assertEqual(imstat.getRms(), 0)
self.assertEqual(imstat.getNpix(), (2 * core + 1)**2)
def testImageStatisticsZero(self):
numArray = num.zeros((20, 20))
mi = afwImage.MaskedImageF(geom.Extent2I(20, 20))
for j in range(mi.getHeight()):
for i in range(mi.getWidth()):
mi[i, j, afwImage.LOCAL] = (numArray[j][i], 0x0, 1)
imstat = ipDiffim.ImageStatisticsF(self.ps)
imstat.apply(mi)
self.assertEqual(imstat.getMean(), 0)
self.assertEqual(imstat.getRms(), 0)
self.assertEqual(imstat.getNpix(), 20 * 20)
def testImageStatisticsOne(self):
numArray = num.ones((20, 20))
mi = afwImage.MaskedImageF(afwGeom.Extent2I(20, 20))
for j in range(mi.getHeight()):
for i in range(mi.getWidth()):
mi.set(i, j, (numArray[j][i], 0x0, 1))
imstat = ipDiffim.ImageStatisticsF(self.policy)
imstat.apply(mi)
self.assertEqual(imstat.getMean(), 1)
self.assertEqual(imstat.getRms(), 0)
self.assertEqual(imstat.getNpix(), 20 * 20)
def apply(self, ps, visitor, xloc, yloc, tmi, smi):
dStats = ipDiffim.ImageStatisticsF(ps)
kc = ipDiffim.makeKernelCandidate(xloc, yloc, tmi, smi, ps)
visitor.processCandidate(kc)
kim = kc.getKernelImage(ipDiffim.KernelCandidateF.RECENT)
diffIm = kc.getDifferenceImage(ipDiffim.KernelCandidateF.RECENT)
kSum = kc.getKsum(ipDiffim.KernelCandidateF.RECENT)
bg = kc.getBackground(ipDiffim.KernelCandidateF.RECENT)
bbox = kc.getKernel(ipDiffim.KernelCandidateF.RECENT).shrinkBBox(
diffIm.getBBox(afwImage.LOCAL))
diffIm = afwImage.MaskedImageF(diffIm, bbox, origin=afwImage.LOCAL)
dStats.apply(diffIm)
dmean = afwMath.makeStatistics(diffIm.getImage(),
afwMath.MEAN).getValue()
dstd = afwMath.makeStatistics(diffIm.getImage(),
afwMath.STDEV).getValue()
vmean = afwMath.makeStatistics(diffIm.getVariance(),
afwMath.MEAN).getValue()
return kSum, bg, dmean, dstd, vmean, kim, diffIm, kc, dStats
def testImageStatisticsGeneral(self):
numArray = num.ones((20, 20))
mi = afwImage.MaskedImageF(afwGeom.Extent2I(20, 20))
for j in range(mi.getHeight()):
for i in range(mi.getWidth()):
val = i + 2.3 * j
mi[i, j, afwImage.LOCAL] = (val, 0x0, 1)
numArray[j][i] = val
imstat = ipDiffim.ImageStatisticsF(self.policy)
imstat.apply(mi)
self.assertAlmostEqual(imstat.getMean(), numArray.mean())
# note that these don't agree exactly...
self.assertAlmostEqual(imstat.getRms(), numArray.std(), 1)
self.assertEqual(imstat.getNpix(), 20 * 20)
afwStat = afwMath.makeStatistics(mi.getImage(), afwMath.MEAN | afwMath.STDEV)
self.assertAlmostEqual(imstat.getMean(), afwStat.getValue(afwMath.MEAN))
# even though these do
self.assertAlmostEqual(imstat.getRms(), afwStat.getValue(afwMath.STDEV))
def testImageStatisticsMask1(self):
# Mask value that gets ignored
maskPlane = self.ps.getArray("badMaskPlanes")[0]
maskVal = afwImage.Mask.getPlaneBitMask(maskPlane)
numArray = num.ones((20, 19))
mi = afwImage.MaskedImageF(geom.Extent2I(20, 20))
for j in range(mi.getHeight()):
for i in range(mi.getWidth()):
val = i + 2.3 * j
if i == 19:
mi[i, j, afwImage.LOCAL] = (val, maskVal, 1)
else:
mi[i, j, afwImage.LOCAL] = (val, 0x0, 1)
numArray[j][i] = val
imstat = ipDiffim.ImageStatisticsF(self.ps)
imstat.apply(mi)
self.assertAlmostEqual(imstat.getMean(), numArray.mean())
# note that these don't agree exactly...
self.assertAlmostEqual(imstat.getRms(), numArray.std(), 1)
self.assertEqual(imstat.getNpix(), 20 * (20 - 1))
def setUp(self):
self.configAL = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.configAL.kernel.name = "AL"
self.subconfigAL = self.configAL.kernel.active
self.configDF = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.configDF.kernel.name = "DF"
self.subconfigDF = self.configDF.kernel.active
self.configDFr = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.configDFr.kernel.name = "DF"
self.subconfigDFr = self.configDFr.kernel.active
self.subconfigDF.useRegularization = False
self.subconfigDFr.useRegularization = True
self.subconfigDFr.lambdaValue = 1000.0
self.subconfigAL.fitForBackground = fitForBackground
self.subconfigDF.fitForBackground = fitForBackground
self.subconfigDFr.fitForBackground = fitForBackground
self.subconfigAL.constantVarianceWeighting = constantVarianceWeighting
self.subconfigDF.constantVarianceWeighting = constantVarianceWeighting
self.subconfigDFr.constantVarianceWeighting = constantVarianceWeighting
self.kListAL = ipDiffim.makeKernelBasisList(self.subconfigAL)
self.kListDF = ipDiffim.makeKernelBasisList(self.subconfigDF)
self.kListDFr = ipDiffim.makeKernelBasisList(self.subconfigDFr)
self.hMatDFr = ipDiffim.makeRegularizationMatrix(
pexConfig.makePolicy(self.subconfigDFr))
self.bskvAL = ipDiffim.BuildSingleKernelVisitorF(
self.kListAL, pexConfig.makePolicy(self.subconfigAL))
self.bskvDF = ipDiffim.BuildSingleKernelVisitorF(
self.kListDF, pexConfig.makePolicy(self.subconfigDF))
self.bskvDFr = ipDiffim.BuildSingleKernelVisitorF(
self.kListDFr, pexConfig.makePolicy(self.subconfigDF),
self.hMatDFr)
defSciencePath = globals()['defSciencePath']
defTemplatePath = globals()['defTemplatePath']
if defSciencePath and defTemplatePath:
self.scienceExposure = afwImage.ExposureF(defSciencePath)
self.templateExposure = afwImage.ExposureF(defTemplatePath)
else:
defDataDir = lsst.utils.getPackageDir('afwdata')
defSciencePath = os.path.join(defDataDir, "DC3a-Sim", "sci",
"v26-e0", "v26-e0-c011-a00.sci")
defTemplatePath = os.path.join(defDataDir, "DC3a-Sim", "sci",
"v5-e0", "v5-e0-c011-a00.sci")
self.scienceExposure = afwImage.ExposureF(defSciencePath)
self.templateExposure = afwImage.ExposureF(defTemplatePath)
warper = afwMath.Warper.fromConfig(self.subconfigAL.warpingConfig)
self.templateExposure = warper.warpExposure(
self.scienceExposure.getWcs(),
self.templateExposure,
destBBox=self.scienceExposure.getBBox())
# image statistics
self.dStats = ipDiffim.ImageStatisticsF()
#
tmi = self.templateExposure.getMaskedImage()
smi = self.scienceExposure.getMaskedImage()
# Object detection
detConfig = self.subconfigAL.detectionConfig
detPolicy = pexConfig.makePolicy(detConfig)
detPolicy.set("detThreshold", 50.)
detPolicy.set("detThresholdType", "stdev")
detPolicy.set("detOnTemplate", False)
kcDetect = ipDiffim.KernelCandidateDetectionF(detPolicy)
kcDetect.apply(tmi, smi)
self.footprints = kcDetect.getFootprints()
def setUp(self, CFHT=True):
lambdaValue = 1.0
self.config1 = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.config1.kernel.name = "DF"
self.subconfig1 = self.config1.kernel.active
self.config2 = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.config2.kernel.name = "DF"
self.subconfig2 = self.config2.kernel.active
self.config3 = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.config3.kernel.name = "DF"
self.subconfig3 = self.config3.kernel.active
self.config4 = ipDiffim.ImagePsfMatchTask.ConfigClass()
self.config4.kernel.name = "DF"
self.subconfig4 = self.config4.kernel.active
self.subconfig1.useRegularization = False
self.subconfig2.useRegularization = True
self.subconfig2.lambdaType = "absolute"
self.subconfig2.lambdaValue = lambdaValue
self.subconfig2.regularizationType = "centralDifference"
self.subconfig2.centralRegularizationStencil = 5
self.subconfig3.useRegularization = True
self.subconfig3.lambdaType = "absolute"
self.subconfig3.lambdaValue = lambdaValue
self.subconfig3.regularizationType = "centralDifference"
self.subconfig3.centralRegularizationStencil = 9
self.subconfig4.useRegularization = True
self.subconfig4.lambdaType = "absolute"
self.subconfig4.lambdaValue = lambdaValue
self.subconfig4.regularizationType = "forwardDifference"
self.subconfig4.forwardRegularizationOrders = [1, 2]
self.kList1 = ipDiffim.makeKernelBasisList(self.subconfig1)
self.bskv1 = ipDiffim.BuildSingleKernelVisitorF(
self.kList1, pexConfig.makePolicy(self.subconfig1))
self.kList2 = ipDiffim.makeKernelBasisList(self.subconfig2)
self.hMat2 = ipDiffim.makeRegularizationMatrix(
pexConfig.makePolicy(self.subconfig2))
self.bskv2 = ipDiffim.BuildSingleKernelVisitorF(
self.kList2, pexConfig.makePolicy(self.subconfig2), self.hMat2)
self.kList3 = ipDiffim.makeKernelBasisList(self.subconfig3)
self.hMat3 = ipDiffim.makeRegularizationMatrix(
pexConfig.makePolicy(self.subconfig3))
self.bskv3 = ipDiffim.BuildSingleKernelVisitorF(
self.kList3, pexConfig.makePolicy(self.subconfig3), self.hMat3)
self.kList4 = ipDiffim.makeKernelBasisList(self.subconfig4)
self.hMat4 = ipDiffim.makeRegularizationMatrix(
pexConfig.makePolicy(self.subconfig4))
self.bskv4 = ipDiffim.BuildSingleKernelVisitorF(
self.kList4, pexConfig.makePolicy(self.subconfig4), self.hMat4)
# known input images
defDataDir = lsst.utils.getPackageDir('afwdata')
if CFHT:
defSciencePath = os.path.join(defDataDir, 'CFHT', 'D4', CFHTTORUN)
defTemplatePath = os.path.join(defDataDir, 'CFHT', 'D4',
CFHTTORUN + '_tmpl')
# no need to remap
self.scienceExposure = afwImage.ExposureF(defSciencePath)
self.templateExposure = afwImage.ExposureF(defTemplatePath)
else:
defSciencePath = os.path.join(defDataDir, "DC3a-Sim", "sci",
"v26-e0", "v26-e0-c011-a00.sci")
defTemplatePath = os.path.join(defDataDir, "DC3a-Sim", "sci",
"v5-e0", "v5-e0-c011-a00.sci")
self.scienceExposure = afwImage.ExposureF(defSciencePath)
self.templateExposure = afwImage.ExposureF(defTemplatePath)
warper = afwMath.Warper.fromConfig(self.subconfig1.warpingConfig)
self.templateExposure = warper.warpExposure(
self.scienceExposure.getWcs(),
self.templateExposure,
destBBox=self.scienceExposure.getBBox())
diffimTools.backgroundSubtract(self.subconfig1.afwBackgroundConfig, [
self.scienceExposure.getMaskedImage(),
self.templateExposure.getMaskedImage()
])
# image statistics
self.dStats = ipDiffim.ImageStatisticsF()
#
tmi = self.templateExposure.getMaskedImage()
smi = self.scienceExposure.getMaskedImage()
detConfig = self.subconfig1.detectionConfig
detPolicy = pexConfig.makePolicy(detConfig)
detPolicy.set("detThreshold", 50.)
detPolicy.set("detOnTemplate", False)
kcDetect = ipDiffim.KernelCandidateDetectionF(detPolicy)
kcDetect.apply(tmi, smi)
self.footprints = kcDetect.getFootprints()
