def testCentralRegularization(self):
# stencil of 1 not allowed
self.psDF["regularizationType"] = "centralDifference"
with self.assertRaises(lsst.pex.exceptions.Exception):
self.psDF["centralRegularizationStencil"] = 1
ipDiffim.makeRegularizationMatrix(self.psDF)
# stencil of 5 allowed
self.psDF["centralRegularizationStencil"] = 5
try:
ipDiffim.makeRegularizationMatrix(self.psDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: stencil of 5 is allowed." % e)
# stencil of 9 allowed
self.psDF["centralRegularizationStencil"] = 9
try:
ipDiffim.makeRegularizationMatrix(self.psDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: stencil of 9 is allowed" % e)
# border penalty < 0
self.psDF["regularizationBorderPenalty"] = -1.0
with self.assertRaises(lsst.pex.exceptions.Exception):
ipDiffim.makeRegularizationMatrix(self.psDF)
# border penalty > 0
self.psDF["regularizationBorderPenalty"] = 0.0
try:
ipDiffim.makeRegularizationMatrix(self.psDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: Border penalty > 0" % e)
def testCentralRegularization(self):
# stencil of 1 not allowed
self.policyDF.set("regularizationType", "centralDifference")
with self.assertRaises(lsst.pex.exceptions.Exception):
self.policyDF.set("centralRegularizationStencil", 1)
ipDiffim.makeRegularizationMatrix(self.policyDF)
# stencil of 5 allowed
self.policyDF.set("centralRegularizationStencil", 5)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: stencil of 5 is allowed."%e)
# stencil of 9 allowed
self.policyDF.set("centralRegularizationStencil", 9)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: stencil of 9 is allowed"%e)
# border penalty < 0
self.policyDF.set("regularizationBorderPenalty", -1.0)
with self.assertRaises(lsst.pex.exceptions.Exception):
ipDiffim.makeRegularizationMatrix(self.policyDF)
# border penalty > 0
self.policyDF.set("regularizationBorderPenalty", 0.0)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: Border penalty > 0"%e)
def testForwardRegularization(self):
self.policyDF.set("regularizationType", "forwardDifference")
self.policyDF.set("forwardRegularizationOrders", 0)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except Exception, e: # order 1..3 allowed
pass
def testCentralRegularization(self):
# stencil of 1 not allowed
self.policyDF.set("regularizationType", "centralDifference")
with self.assertRaises(lsst.pex.exceptions.Exception):
self.policyDF.set("centralRegularizationStencil", 1)
ipDiffim.makeRegularizationMatrix(self.policyDF)
# stencil of 5 allowed
self.policyDF.set("centralRegularizationStencil", 5)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: stencil of 5 is allowed." % e)
# stencil of 9 allowed
self.policyDF.set("centralRegularizationStencil", 9)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: stencil of 9 is allowed" % e)
# border penalty < 0
self.policyDF.set("regularizationBorderPenalty", -1.0)
with self.assertRaises(lsst.pex.exceptions.Exception):
ipDiffim.makeRegularizationMatrix(self.policyDF)
# border penalty > 0
self.policyDF.set("regularizationBorderPenalty", 0.0)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: Border penalty > 0" % e)
def testBadRegularization(self):
try:
self.policyDF.set("regularizationType", "foo")
ipDiffim.makeRegularizationMatrix(self.policyDF)
except Exception: # invalid option
pass
else:
self.fail()
def testCentralRegularization(self):
#
self.policyDF.set("regularizationType", "centralDifference")
try:
self.policyDF.set("centralRegularizationStencil", 1)
ipDiffim.makeRegularizationMatrix(self.policyDF)
except Exception, e: # stencil of 1 not allowed
pass
def runWithOneBasis(self, useRegularization):
kc1 = self.makeCandidate(1, 0.0, 0.0)
kc2 = self.makeCandidate(2, 0.0, 0.0)
kc3 = self.makeCandidate(3, 0.0, 0.0)
if useRegularization:
hMat = ipDiffim.makeRegularizationMatrix(self.policy)
bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.policy, hMat)
else:
bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.policy)
bskv.processCandidate(kc1)
bskv.processCandidate(kc2)
bskv.processCandidate(kc3)
# Initialized
self.assertEqual(kc1.isInitialized(), True)
self.assertEqual(kc2.isInitialized(), True)
self.assertEqual(kc3.isInitialized(), True)
# Is a solution
try:
kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT)
kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT)
kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT)
except Exception, e:
print e
self.fail()
def runWithOneBasis(self, useRegularization):
kc1 = self.makeCandidate(1, 0.0, 0.0)
kc2 = self.makeCandidate(2, 0.0, 0.0)
kc3 = self.makeCandidate(3, 0.0, 0.0)
if useRegularization:
hMat = ipDiffim.makeRegularizationMatrix(self.ps)
bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps,
hMat)
else:
bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps)
bskv.processCandidate(kc1)
bskv.processCandidate(kc2)
bskv.processCandidate(kc3)
# Initialized
self.assertEqual(kc1.isInitialized(), True)
self.assertEqual(kc2.isInitialized(), True)
self.assertEqual(kc3.isInitialized(), True)
# Is a solution
try:
kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT)
kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT)
kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT)
except Exception as e:
print(e)
self.fail()
# Its not the Pca one
try:
kc1.getKernelSolution(ipDiffim.KernelCandidateF.PCA)
kc2.getKernelSolution(ipDiffim.KernelCandidateF.PCA)
kc3.getKernelSolution(ipDiffim.KernelCandidateF.PCA)
except Exception:
pass
else:
self.fail()
# Processed all of them
self.assertEqual(bskv.getNProcessed(), 3)
# Rejected none
self.assertEqual(bskv.getNRejected(), 0)
# Skips built candidates
bskv.reset()
bskv.setSkipBuilt(True)
bskv.processCandidate(kc1)
bskv.processCandidate(kc2)
bskv.processCandidate(kc3)
# Processed none of them
self.assertEqual(bskv.getNProcessed(), 0)
def runWithOneBasis(self, useRegularization):
kc1 = self.makeCandidate(1, 0.0, 0.0)
kc2 = self.makeCandidate(2, 0.0, 0.0)
kc3 = self.makeCandidate(3, 0.0, 0.0)
if useRegularization:
hMat = ipDiffim.makeRegularizationMatrix(self.policy)
bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.policy, hMat)
else:
bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.policy)
bskv.processCandidate(kc1)
bskv.processCandidate(kc2)
bskv.processCandidate(kc3)
# Initialized
self.assertEqual(kc1.isInitialized(), True)
self.assertEqual(kc2.isInitialized(), True)
self.assertEqual(kc3.isInitialized(), True)
# Is a solution
try:
kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT)
kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT)
kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT)
except Exception as e:
print(e)
self.fail()
# Its not the Pca one
try:
kc1.getKernelSolution(ipDiffim.KernelCandidateF.PCA)
kc2.getKernelSolution(ipDiffim.KernelCandidateF.PCA)
kc3.getKernelSolution(ipDiffim.KernelCandidateF.PCA)
except Exception:
pass
else:
self.fail()
# Processed all of them
self.assertEqual(bskv.getNProcessed(), 3)
# Rejected none
self.assertEqual(bskv.getNRejected(), 0)
# Skips built candidates
bskv.reset()
bskv.setSkipBuilt(True)
bskv.processCandidate(kc1)
bskv.processCandidate(kc2)
bskv.processCandidate(kc3)
# Processed none of them
self.assertEqual(bskv.getNProcessed(), 0)
def testForwardRegularization(self):
self.psDF["regularizationType"] = "forwardDifference"
# order 1..3 allowed
self.psDF["forwardRegularizationOrders"] = 0
with self.assertRaises(lsst.pex.exceptions.Exception):
ipDiffim.makeRegularizationMatrix(self.psDF)
self.psDF["forwardRegularizationOrders"] = 1
try:
ipDiffim.makeRegularizationMatrix(self.psDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: order 1 allowed" % e)
self.psDF["forwardRegularizationOrders"] = 4
with self.assertRaises(lsst.pex.exceptions.Exception):
ipDiffim.makeRegularizationMatrix(self.psDF)
self.psDF["forwardRegularizationOrders"] = [1, 2]
try:
ipDiffim.makeRegularizationMatrix(self.psDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: order 1,2 allowed" % e)
def testForwardRegularization(self):
self.policyDF.set("regularizationType", "forwardDifference")
# order 1..3 allowed
self.policyDF.set("forwardRegularizationOrders", 0)
with self.assertRaises(lsst.pex.exceptions.Exception):
ipDiffim.makeRegularizationMatrix(self.policyDF)
self.policyDF.set("forwardRegularizationOrders", 1)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: order 1 allowed" % e)
self.policyDF.set("forwardRegularizationOrders", 4)
with self.assertRaises(lsst.pex.exceptions.Exception):
ipDiffim.makeRegularizationMatrix(self.policyDF)
self.policyDF.set("forwardRegularizationOrders", 1)
self.policyDF.add("forwardRegularizationOrders", 2)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: order 1,2 allowed" % e)
def testForwardRegularization(self):
self.policyDF.set("regularizationType", "forwardDifference")
# order 1..3 allowed
self.policyDF.set("forwardRegularizationOrders", 0)
with self.assertRaises(lsst.pex.exceptions.Exception):
ipDiffim.makeRegularizationMatrix(self.policyDF)
self.policyDF.set("forwardRegularizationOrders", 1)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: order 1 allowed"%e)
self.policyDF.set("forwardRegularizationOrders", 4)
with self.assertRaises(lsst.pex.exceptions.Exception):
ipDiffim.makeRegularizationMatrix(self.policyDF)
self.policyDF.set("forwardRegularizationOrders", 1)
self.policyDF.add("forwardRegularizationOrders", 2)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except lsst.pex.exceptions.Exception as e:
self.fail("Should not raise %s: order 1,2 allowed"%e)
def testBadRegularization(self):
with self.assertRaises(lsst.pex.exceptions.Exception):
self.policyDF.set("regularizationType", "foo")
ipDiffim.makeRegularizationMatrix(self.policyDF)
def testBadRegularization(self):
with self.assertRaises(lsst.pex.exceptions.Exception):
self.psDF["regularizationType"] = "foo"
ipDiffim.makeRegularizationMatrix(self.psDF)
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.makePropertySet(self.subconfig1))
self.kList2 = ipDiffim.makeKernelBasisList(self.subconfig2)
self.hMat2 = ipDiffim.makeRegularizationMatrix(
pexConfig.makePropertySet(self.subconfig2))
self.bskv2 = ipDiffim.BuildSingleKernelVisitorF(
self.kList2, pexConfig.makePropertySet(self.subconfig2),
self.hMat2)
self.kList3 = ipDiffim.makeKernelBasisList(self.subconfig3)
self.hMat3 = ipDiffim.makeRegularizationMatrix(
pexConfig.makePropertySet(self.subconfig3))
self.bskv3 = ipDiffim.BuildSingleKernelVisitorF(
self.kList3, pexConfig.makePropertySet(self.subconfig3),
self.hMat3)
self.kList4 = ipDiffim.makeKernelBasisList(self.subconfig4)
self.hMat4 = ipDiffim.makeRegularizationMatrix(
pexConfig.makePropertySet(self.subconfig4))
self.bskv4 = ipDiffim.BuildSingleKernelVisitorF(
self.kList4, pexConfig.makePropertySet(self.subconfig4),
self.hMat4)
# known input images
defDataDir = lsst.utils.getPackageDir('afwdata')
if CFHT:
defSciencePath = os.path.join(defDataDir, 'CFHT', 'D4',
CFHTTORUN + '.fits')
defTemplatePath = os.path.join(defDataDir, 'CFHT', 'D4',
CFHTTORUN + '_tmpl.fits')
# 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()
])
#
tmi = self.templateExposure.getMaskedImage()
smi = self.scienceExposure.getMaskedImage()
detConfig = self.subconfig1.detectionConfig
detps = pexConfig.makePropertySet(detConfig)
detps["detThreshold"] = 50.
detps["detOnTemplate"] = False
kcDetect = ipDiffim.KernelCandidateDetectionF(detps)
kcDetect.apply(tmi, smi)
self.footprints = kcDetect.getFootprints()
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.makePropertySet(self.subconfigDFr))
self.bskvAL = ipDiffim.BuildSingleKernelVisitorF(
self.kListAL, pexConfig.makePropertySet(self.subconfigAL))
self.bskvDF = ipDiffim.BuildSingleKernelVisitorF(
self.kListDF, pexConfig.makePropertySet(self.subconfigDF))
self.bskvDFr = ipDiffim.BuildSingleKernelVisitorF(
self.kListDFr, pexConfig.makePropertySet(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.fits")
defTemplatePath = os.path.join(defDataDir, "DC3a-Sim", "sci",
"v5-e0", "v5-e0-c011-a00.sci.fits")
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())
#
tmi = self.templateExposure.getMaskedImage()
smi = self.scienceExposure.getMaskedImage()
# Object detection
detConfig = self.subconfigAL.detectionConfig
detps = pexConfig.makePropertySet(detConfig)
detps["detThreshold"] = 50.
detps["detThresholdType"] = "stdev"
detps["detOnTemplate"] = False
kcDetect = ipDiffim.KernelCandidateDetectionF(detps)
kcDetect.apply(tmi, smi)
self.footprints = kcDetect.getFootprints()
#
def testCentralRegularization(self):
#
self.policyDF.set("regularizationType", "centralDifference")
try:
self.policyDF.set("centralRegularizationStencil", 1)
ipDiffim.makeRegularizationMatrix(self.policyDF)
except Exception, e: # stencil of 1 not allowed
pass
else:
self.fail()
self.policyDF.set("centralRegularizationStencil", 5)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except Exception, e: # stencil of 5 allowed
print e
self.fail()
else:
pass
self.policyDF.set("centralRegularizationStencil", 9)
try:
ipDiffim.makeRegularizationMatrix(self.policyDF)
except Exception, e: # stencil of 9 allowed
print e
self.fail()
else:
pass
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.fits")
defTemplatePath = os.path.join(defDataDir, "DC3a-Sim", "sci", "v5-e0",
"v5-e0-c011-a00.sci.fits")
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())
#
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 testBadRegularization(self):
with self.assertRaises(lsst.pex.exceptions.Exception):
self.policyDF.set("regularizationType", "foo")
ipDiffim.makeRegularizationMatrix(self.policyDF)
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+'.fits')
defTemplatePath = os.path.join(defDataDir, 'CFHT', 'D4', CFHTTORUN+'_tmpl.fits')
# 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()])
#
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()
