Coverage for tests/test_kernelPca.py: 14%
Shortcuts on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
Shortcuts on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1import unittest
4import lsst.utils.tests
5import lsst.afw.image as afwImage
6import lsst.afw.math as afwMath
7import lsst.geom as geom
8import lsst.ip.diffim as ipDiffim
9import lsst.ip.diffim.diffimTools as diffimTools
10import lsst.utils.logging as logUtils
11import lsst.pex.config as pexConfig
13logUtils.trace_set_at("lsst.ip.diffim", 4)
16class DiffimTestCases(lsst.utils.tests.TestCase):
18 def setUp(self):
19 self.config = ipDiffim.ImagePsfMatchTask.ConfigClass()
20 self.config.kernel.name = "DF"
21 self.subconfig = self.config.kernel.active
23 self.kList = ipDiffim.makeKernelBasisList(self.subconfig)
24 self.ps = pexConfig.makePropertySet(self.subconfig)
25 self.ps["useRegularization"] = False
27 def tearDown(self):
28 del self.config
29 del self.ps
30 del self.kList
32 def makeCandidate(self, kSum, x, y, size=51):
33 mi1 = afwImage.MaskedImageF(geom.Extent2I(size, size))
34 mi1.getVariance().set(1.0) # avoid NaNs
35 mi1[size//2, size//2, afwImage.LOCAL] = (1, 0x0, 1)
36 mi2 = afwImage.MaskedImageF(geom.Extent2I(size, size))
37 mi2.getVariance().set(1.0) # avoid NaNs
38 mi2[size//2, size//2, afwImage.LOCAL] = (kSum, 0x0, kSum)
39 kc = ipDiffim.makeKernelCandidate(x, y, mi1, mi2, self.ps)
40 return kc
42 def testGaussian(self, size=51):
43 gaussFunction = afwMath.GaussianFunction2D(2, 3)
44 gaussKernel = afwMath.AnalyticKernel(size, size, gaussFunction)
46 imagePca1 = ipDiffim.KernelPcaD() # mean subtract
47 imagePca2 = ipDiffim.KernelPcaD() # don't mean subtract
48 kpv1 = ipDiffim.KernelPcaVisitorF(imagePca1)
49 kpv2 = ipDiffim.KernelPcaVisitorF(imagePca2)
51 kRefIm = None
53 for i in range(100):
54 kImage1 = afwImage.ImageD(gaussKernel.getDimensions())
55 gaussKernel.computeImage(kImage1, False)
56 kImage1 *= 10000 # to get some decent peak source counts
57 kImage1 += 10 # to get some sky background noise
59 if kRefIm is None:
60 kRefIm = kImage1
62 kImage1 = diffimTools.makePoissonNoiseImage(kImage1)
63 kImage2 = afwImage.ImageD(kImage1, True)
65 imagePca1.addImage(kImage1, 1.0)
66 imagePca2.addImage(kImage2, 1.0)
68 kpv1.subtractMean()
70 imagePca1.analyze()
71 imagePca2.analyze()
73 pcaBasisList1 = kpv1.getEigenKernels()
74 pcaBasisList2 = kpv2.getEigenKernels()
76 eVal1 = imagePca1.getEigenValues()
77 eVal2 = imagePca2.getEigenValues()
79 # First term is far more signficant without mean subtraction
80 self.assertGreater(eVal2[0], eVal1[0])
82 # Last term basically zero with mean subtraction
83 self.assertAlmostEqual(eVal1[-1], 0.0)
85 # Extra image with mean subtraction
86 self.assertEqual(len(pcaBasisList1), (len(eVal1) + 1))
88 # Same shape
89 self.assertEqual(len(pcaBasisList2), len(eVal2))
91 # Mean kernel close to kRefIm
92 kImageM = afwImage.ImageD(gaussKernel.getDimensions())
93 pcaBasisList1[0].computeImage(kImageM, False)
94 for y in range(kRefIm.getHeight()):
95 for x in range(kRefIm.getWidth()):
96 self.assertLess(abs(kRefIm[x, y, afwImage.LOCAL] - kImageM[x, y, afwImage.LOCAL])
97 / kRefIm[x, y, afwImage.LOCAL], 0.2)
99 # First mean-unsubtracted Pca kernel close to kRefIm (normalized to peak of 1.0)
100 kImage0 = afwImage.ImageD(gaussKernel.getDimensions())
101 pcaBasisList2[0].computeImage(kImage0, False)
102 maxVal = afwMath.makeStatistics(kRefIm, afwMath.MAX).getValue(afwMath.MAX)
103 kRefIm /= maxVal
104 for y in range(kRefIm.getHeight()):
105 for x in range(kRefIm.getWidth()):
106 self.assertLess(abs(kRefIm[x, y, afwImage.LOCAL] - kImage0[x, y, afwImage.LOCAL])
107 / kRefIm[x, y, afwImage.LOCAL], 0.2)
109 def testImagePca(self):
110 # Test out the ImagePca behavior
111 kc1 = self.makeCandidate(1, 0.0, 0.0)
112 kc1.build(self.kList)
113 kc2 = self.makeCandidate(2, 0.0, 0.0)
114 kc2.build(self.kList)
115 kc3 = self.makeCandidate(3, 0.0, 0.0)
116 kc3.build(self.kList)
118 imagePca = ipDiffim.KernelPcaD()
119 kpv = ipDiffim.KernelPcaVisitorF(imagePca)
120 kpv.processCandidate(kc1)
121 kpv.processCandidate(kc2)
122 kpv.processCandidate(kc3)
124 imagePca.analyze()
125 eigenImages = imagePca.getEigenImages()
126 # NOTE : this needs to be changed once ticket #1649 is resolved
127 for i in range(len(eigenImages)):
128 for j in range(i, len(eigenImages)):
129 print(i, j, afwImage.innerProduct(eigenImages[i], eigenImages[j]))
131 def testEigenValues(self):
132 kc1 = self.makeCandidate(1, 0.0, 0.0)
133 kc1.build(self.kList)
135 kc2 = self.makeCandidate(2, 0.0, 0.0)
136 kc2.build(self.kList)
138 kc3 = self.makeCandidate(3, 0.0, 0.0)
139 kc3.build(self.kList)
141 imagePca = ipDiffim.KernelPcaD()
142 kpv = ipDiffim.KernelPcaVisitorF(imagePca)
143 kpv.processCandidate(kc1)
144 kpv.processCandidate(kc2)
145 kpv.processCandidate(kc3)
147 imagePca.analyze()
148 eigenImages = imagePca.getEigenImages()
149 eigenValues = imagePca.getEigenValues()
151 # took in 3 images
152 self.assertEqual(len(eigenImages), 3)
153 self.assertEqual(len(eigenValues), 3)
155 # all the same shape, only 1 eigenvalue
156 self.assertAlmostEqual(eigenValues[0], 1.0)
157 self.assertAlmostEqual(eigenValues[1], 0.0)
158 self.assertAlmostEqual(eigenValues[2], 0.0)
160 def testMeanSubtraction(self):
161 kc1 = self.makeCandidate(1, 0.0, 0.0)
162 kc1.build(self.kList)
164 kc2 = self.makeCandidate(2, 0.0, 0.0)
165 kc2.build(self.kList)
167 kc3 = self.makeCandidate(3, 0.0, 0.0)
168 kc3.build(self.kList)
170 imagePca = ipDiffim.KernelPcaD()
171 kpv = ipDiffim.KernelPcaVisitorF(imagePca)
172 kpv.processCandidate(kc1)
173 kpv.processCandidate(kc2)
174 kpv.processCandidate(kc3)
175 kpv.subtractMean() # subtract it *from* imagePca
177 imagePca.analyze()
178 eigenImages = imagePca.getEigenImages()
179 eigenValues = imagePca.getEigenValues()
181 # took in 3 images
182 self.assertEqual(len(eigenImages), 3)
183 self.assertEqual(len(eigenValues), 3)
185 # all the same shape, mean subtracted, so *no* eigenvalues
186 self.assertAlmostEqual(eigenValues[0], 0.0)
187 self.assertAlmostEqual(eigenValues[1], 0.0)
188 self.assertAlmostEqual(eigenValues[2], 0.0)
190 # finally, since imagePca normalizes by the sum, this should
191 # have central pixel value 1.0 and the rest 0.0
192 imageMean = kpv.returnMean()
193 rows = imageMean.getHeight()
194 cols = imageMean.getWidth()
195 for y in range(rows):
196 for x in range(cols):
197 if x == cols // 2 and y == rows // 2:
198 self.assertAlmostEqual(imageMean[x, y, afwImage.LOCAL], 1.0)
199 else:
200 self.assertAlmostEqual(imageMean[x, y, afwImage.LOCAL], 0.0)
202 def testVisit(self, nCell=3):
203 imagePca = ipDiffim.KernelPcaD()
204 kpv = ipDiffim.makeKernelPcaVisitor(imagePca)
206 sizeCellX = self.ps["sizeCellX"]
207 sizeCellY = self.ps["sizeCellY"]
209 kernelCellSet = afwMath.SpatialCellSet(geom.Box2I(geom.Point2I(0, 0),
210 geom.Extent2I(sizeCellX * nCell,
211 sizeCellY * nCell)),
212 sizeCellX,
213 sizeCellY)
215 for candX in range(nCell):
216 for candY in range(nCell):
217 if candX == nCell // 2 and candY == nCell // 2:
218 kc = self.makeCandidate(100.0,
219 candX * sizeCellX + sizeCellX // 2,
220 candY * sizeCellY + sizeCellY // 2)
221 else:
222 kc = self.makeCandidate(1.0,
223 candX * sizeCellX + sizeCellX // 2,
224 candY * sizeCellY + sizeCellY // 2)
225 kc.build(self.kList)
226 kernelCellSet.insertCandidate(kc)
228 kernelCellSet.visitCandidates(kpv, 1)
229 imagePca.analyze()
230 eigenImages = imagePca.getEigenImages()
231 eigenValues = imagePca.getEigenValues()
233 # took in 3 images
234 self.assertEqual(len(eigenImages), nCell * nCell)
235 self.assertEqual(len(eigenValues), nCell * nCell)
237 # all the same shape, only 1 eigenvalue
238 self.assertAlmostEqual(eigenValues[0], 1.0)
239 self.assertAlmostEqual(eigenValues[1], 0.0)
240 self.assertAlmostEqual(eigenValues[2], 0.0)
242#####
245class TestMemory(lsst.utils.tests.MemoryTestCase):
246 pass
249def setup_module(module):
250 lsst.utils.tests.init()
253if __name__ == "__main__": 253 ↛ 254line 253 didn't jump to line 254, because the condition on line 253 was never true
254 lsst.utils.tests.init()
255 unittest.main()