def testEigenValues(self):
kc1 = self.makeCandidate(1, 0.0, 0.0)
kc1.build(self.kList)
kc2 = self.makeCandidate(2, 0.0, 0.0)
kc2.build(self.kList)
kc3 = self.makeCandidate(3, 0.0, 0.0)
kc3.build(self.kList)
imagePca = ipDiffim.KernelPcaD()
kpv = ipDiffim.KernelPcaVisitorF(imagePca)
kpv.processCandidate(kc1)
kpv.processCandidate(kc2)
kpv.processCandidate(kc3)
imagePca.analyze()
eigenImages = imagePca.getEigenImages()
eigenValues = imagePca.getEigenValues()
# took in 3 images
self.assertEqual(len(eigenImages), 3)
self.assertEqual(len(eigenValues), 3)
# all the same shape, only 1 eigenvalue
self.assertAlmostEqual(eigenValues[0], 1.0)
self.assertAlmostEqual(eigenValues[1], 0.0)
self.assertAlmostEqual(eigenValues[2], 0.0)
def testRejection(self):
# we need to construct a candidate whose shape does not
# match the underlying basis
#
# so lets just make a kernel list with all the power in
# the center, but the candidate requires some off center
# power
kc1 = self.makeCandidate(1, 0.0, 0.0)
kc2 = self.makeCandidate(2, 0.0, 0.0)
kc3 = self.makeCandidate(3, 0.0, 0.0)
bskv1 = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps)
bskv1.processCandidate(kc1)
bskv1.processCandidate(kc2)
bskv1.processCandidate(kc3)
imagePca = ipDiffim.KernelPcaD()
kpv = ipDiffim.KernelPcaVisitorF(imagePca)
kpv.processCandidate(kc1)
kpv.processCandidate(kc2)
kpv.processCandidate(kc3)
kpv.subtractMean()
imagePca.analyze()
eigenKernels = []
eigenKernels.append(kpv.getEigenKernels()[0])
self.assertEqual(len(eigenKernels), 1)
# bogus candidate
mi1 = afwImage.MaskedImageF(geom.Extent2I(self.size, self.size))
mi1.getVariance().set(0.1)
mi1[self.size // 2, self.size // 2, afwImage.LOCAL] = (1, 0x0, 1)
mi2 = afwImage.MaskedImageF(geom.Extent2I(self.size, self.size))
mi2.getVariance().set(0.1)
# make it high enough to make the mean resids large
mi2[self.size // 3, self.size // 3,
afwImage.LOCAL] = (self.size**2, 0x0, 1)
kc4 = ipDiffim.makeKernelCandidate(0, 0, mi1, mi2, self.ps)
self.assertEqual(kc4.getStatus(), afwMath.SpatialCellCandidate.UNKNOWN)
# process with eigenKernels
bskv2 = ipDiffim.BuildSingleKernelVisitorF(eigenKernels, self.ps)
bskv2.setSkipBuilt(False)
bskv2.processCandidate(kc1)
bskv2.processCandidate(kc2)
bskv2.processCandidate(kc3)
bskv2.processCandidate(kc4)
self.assertEqual(bskv2.getNProcessed(), 4)
self.assertEqual(bskv2.getNRejected(), 1)
self.assertEqual(kc1.getStatus(), afwMath.SpatialCellCandidate.GOOD)
self.assertEqual(kc2.getStatus(), afwMath.SpatialCellCandidate.GOOD)
self.assertEqual(kc3.getStatus(), afwMath.SpatialCellCandidate.GOOD)
self.assertEqual(kc4.getStatus(), afwMath.SpatialCellCandidate.BAD)
def testMeanSubtraction(self):
kc1 = self.makeCandidate(1, 0.0, 0.0)
kc1.build(self.kList)
kc2 = self.makeCandidate(2, 0.0, 0.0)
kc2.build(self.kList)
kc3 = self.makeCandidate(3, 0.0, 0.0)
kc3.build(self.kList)
imagePca = ipDiffim.KernelPcaD()
kpv = ipDiffim.KernelPcaVisitorF(imagePca)
kpv.processCandidate(kc1)
kpv.processCandidate(kc2)
kpv.processCandidate(kc3)
kpv.subtractMean() # subtract it *from* imagePca
imagePca.analyze()
eigenImages = imagePca.getEigenImages()
eigenValues = imagePca.getEigenValues()
# took in 3 images
self.assertEqual(len(eigenImages), 3)
self.assertEqual(len(eigenValues), 3)
# all the same shape, mean subtracted, so *no* eigenvalues
self.assertAlmostEqual(eigenValues[0], 0.0)
self.assertAlmostEqual(eigenValues[1], 0.0)
self.assertAlmostEqual(eigenValues[2], 0.0)
# finally, since imagePca normalizes by the sum, this should
# have central pixel value 1.0 and the rest 0.0
imageMean = kpv.returnMean()
rows = imageMean.getHeight()
cols = imageMean.getWidth()
for y in range(rows):
for x in range(cols):
if x == cols // 2 and y == rows // 2:
self.assertAlmostEqual(imageMean[x, y, afwImage.LOCAL],
1.0)
else:
self.assertAlmostEqual(imageMean[x, y, afwImage.LOCAL],
0.0)
def testImagePca(self):
# Test out the ImagePca behavior
kc1 = self.makeCandidate(1, 0.0, 0.0)
kc1.build(self.kList)
kc2 = self.makeCandidate(2, 0.0, 0.0)
kc2.build(self.kList)
kc3 = self.makeCandidate(3, 0.0, 0.0)
kc3.build(self.kList)
imagePca = ipDiffim.KernelPcaD()
kpv = ipDiffim.KernelPcaVisitorF(imagePca)
kpv.processCandidate(kc1)
kpv.processCandidate(kc2)
kpv.processCandidate(kc3)
imagePca.analyze()
eigenImages = imagePca.getEigenImages()
# NOTE : this needs to be changed once ticket #1649 is resolved
for i in range(len(eigenImages)):
for j in range(i, len(eigenImages)):
print i, j, afwImage.innerProduct(eigenImages[i], eigenImages[j])
def testVisit(self, nCell = 3):
imagePca = ipDiffim.KernelPcaD()
kpv = ipDiffim.makeKernelPcaVisitor(imagePca)
sizeCellX = self.policy.get("sizeCellX")
sizeCellY = self.policy.get("sizeCellY")
kernelCellSet = afwMath.SpatialCellSet(afwGeom.Box2I(afwGeom.Point2I(0,
0),
afwGeom.Extent2I(sizeCellX * nCell,
sizeCellY * nCell)),
sizeCellX,
sizeCellY)
for candX in range(nCell):
for candY in range(nCell):
if candX == nCell // 2 and candY == nCell // 2:
kc = self.makeCandidate(100.0,
candX * sizeCellX + sizeCellX // 2,
candY * sizeCellY + sizeCellY // 2)
else:
kc = self.makeCandidate(1.0,
candX * sizeCellX + sizeCellX // 2,
candY * sizeCellY + sizeCellY // 2)
kc.build(self.kList)
kernelCellSet.insertCandidate(kc)
kernelCellSet.visitCandidates(kpv, 1)
imagePca.analyze()
eigenImages = imagePca.getEigenImages()
eigenValues = imagePca.getEigenValues()
# took in 3 images
self.assertEqual(len(eigenImages), nCell * nCell)
self.assertEqual(len(eigenValues), nCell * nCell)
# all the same shape, only 1 eigenvalue
self.assertAlmostEqual(eigenValues[0], 1.0)
self.assertAlmostEqual(eigenValues[1], 0.0)
self.assertAlmostEqual(eigenValues[2], 0.0)
def testWithThreeBases(self):
kc1 = self.makeCandidate(1, 0.0, 0.0)
kc2 = self.makeCandidate(2, 0.0, 0.0)
kc3 = self.makeCandidate(3, 0.0, 0.0)
bskv1 = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.policy)
bskv1.processCandidate(kc1)
bskv1.processCandidate(kc2)
bskv1.processCandidate(kc3)
self.assertEqual(bskv1.getNProcessed(), 3)
# make sure orig solution is the current one
soln1_1 = kc1.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId()
soln2_1 = kc2.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId()
soln3_1 = kc3.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId()
self.assertEqual(soln1_1, kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId())
self.assertEqual(soln2_1, kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId())
self.assertEqual(soln3_1, kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId())
# do pca basis; visit manually since visitCandidates is still broken
imagePca = ipDiffim.KernelPcaD()
kpv = ipDiffim.KernelPcaVisitorF(imagePca)
kpv.processCandidate(kc1)
kpv.processCandidate(kc2)
kpv.processCandidate(kc3)
kpv.subtractMean()
imagePca.analyze()
eigenKernels = []
eigenKernels.append(kpv.getEigenKernels()[0])
self.assertEqual(len(eigenKernels), 1) # the other eKernels are 0.0 and you can't get their coeffs!
# do twice to mimic a Pca loop
bskv2 = ipDiffim.BuildSingleKernelVisitorF(eigenKernels, self.policy)
bskv2.setSkipBuilt(False)
bskv2.processCandidate(kc1)
bskv2.processCandidate(kc2)
bskv2.processCandidate(kc3)
self.assertEqual(bskv2.getNProcessed(), 3)
soln1_2 = kc1.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId()
soln2_2 = kc2.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId()
soln3_2 = kc3.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId()
# pca is recent
self.assertEqual(soln1_2, kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId())
self.assertEqual(soln2_2, kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId())
self.assertEqual(soln3_2, kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId())
# orig is still orig
self.assertEqual(soln1_1, kc1.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId())
self.assertEqual(soln2_1, kc2.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId())
self.assertEqual(soln3_1, kc3.getKernelSolution(ipDiffim.KernelCandidateF.ORIG).getId())
# pca is not orig
self.assertNotEqual(soln1_2, soln1_1)
self.assertNotEqual(soln2_2, soln2_1)
self.assertNotEqual(soln3_2, soln3_1)
# do twice to mimic a Pca loop
bskv3 = ipDiffim.BuildSingleKernelVisitorF(eigenKernels, self.policy)
bskv3.setSkipBuilt(False)
bskv3.processCandidate(kc1)
bskv3.processCandidate(kc2)
bskv3.processCandidate(kc3)
self.assertEqual(bskv3.getNProcessed(), 3)
soln1_3 = kc1.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId()
soln2_3 = kc2.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId()
soln3_3 = kc3.getKernelSolution(ipDiffim.KernelCandidateF.PCA).getId()
# pca is recent
self.assertEqual(soln1_3, kc1.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId())
self.assertEqual(soln2_3, kc2.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId())
self.assertEqual(soln3_3, kc3.getKernelSolution(ipDiffim.KernelCandidateF.RECENT).getId())
# pca is not previous pca
self.assertNotEqual(soln1_2, soln1_3)
self.assertNotEqual(soln2_2, soln2_3)
self.assertNotEqual(soln3_2, soln3_3)
def testGaussian(self, size=51):
gaussFunction = afwMath.GaussianFunction2D(2, 3)
gaussKernel = afwMath.AnalyticKernel(size, size, gaussFunction)
imagePca1 = ipDiffim.KernelPcaD() # mean subtract
imagePca2 = ipDiffim.KernelPcaD() # don't mean subtract
kpv1 = ipDiffim.KernelPcaVisitorF(imagePca1)
kpv2 = ipDiffim.KernelPcaVisitorF(imagePca2)
kRefIm = None
for i in range(100):
kImage1 = afwImage.ImageD(gaussKernel.getDimensions())
gaussKernel.computeImage(kImage1, False)
kImage1 *= 10000 # to get some decent peak source counts
kImage1 += 10 # to get some sky background noise
if kRefIm is None:
kRefIm = kImage1
kImage1 = diffimTools.makePoissonNoiseImage(kImage1)
kImage2 = afwImage.ImageD(kImage1, True)
imagePca1.addImage(kImage1, 1.0)
imagePca2.addImage(kImage2, 1.0)
kpv1.subtractMean()
imagePca1.analyze()
imagePca2.analyze()
pcaBasisList1 = kpv1.getEigenKernels()
pcaBasisList2 = kpv2.getEigenKernels()
eVal1 = imagePca1.getEigenValues()
eVal2 = imagePca2.getEigenValues()
# First term is far more signficant without mean subtraction
self.assertGreater(eVal2[0], eVal1[0])
# Last term basically zero with mean subtraction
self.assertAlmostEqual(eVal1[-1], 0.0)
# Extra image with mean subtraction
self.assertEqual(len(pcaBasisList1), (len(eVal1) + 1))
# Same shape
self.assertEqual(len(pcaBasisList2), len(eVal2))
# Mean kernel close to kRefIm
kImageM = afwImage.ImageD(gaussKernel.getDimensions())
pcaBasisList1[0].computeImage(kImageM, False)
for y in range(kRefIm.getHeight()):
for x in range(kRefIm.getWidth()):
self.assertLess(
abs(kRefIm[x, y, afwImage.LOCAL] -
kImageM[x, y, afwImage.LOCAL]) /
kRefIm[x, y, afwImage.LOCAL], 0.2)
# First mean-unsubtracted Pca kernel close to kRefIm (normalized to peak of 1.0)
kImage0 = afwImage.ImageD(gaussKernel.getDimensions())
pcaBasisList2[0].computeImage(kImage0, False)
maxVal = afwMath.makeStatistics(kRefIm,
afwMath.MAX).getValue(afwMath.MAX)
kRefIm /= maxVal
for y in range(kRefIm.getHeight()):
for x in range(kRefIm.getWidth()):
self.assertLess(
abs(kRefIm[x, y, afwImage.LOCAL] -
kImage0[x, y, afwImage.LOCAL]) /
kRefIm[x, y, afwImage.LOCAL], 0.2)
