Coverage for tests/test_kernelPca.py: 12%

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

168 statements  

1import unittest 

2 

3 

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.log.utils as logUtils 

11import lsst.pex.config as pexConfig 

12 

13logUtils.traceSetAt("lsst.ip.diffim", 4) 

14 

15 

16class DiffimTestCases(lsst.utils.tests.TestCase): 

17 

18 def setUp(self): 

19 self.config = ipDiffim.ImagePsfMatchTask.ConfigClass() 

20 self.config.kernel.name = "DF" 

21 self.subconfig = self.config.kernel.active 

22 

23 self.kList = ipDiffim.makeKernelBasisList(self.subconfig) 

24 self.ps = pexConfig.makePropertySet(self.subconfig) 

25 self.ps["useRegularization"] = False 

26 

27 def tearDown(self): 

28 del self.config 

29 del self.ps 

30 del self.kList 

31 

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 

41 

42 def testGaussian(self, size=51): 

43 gaussFunction = afwMath.GaussianFunction2D(2, 3) 

44 gaussKernel = afwMath.AnalyticKernel(size, size, gaussFunction) 

45 

46 imagePca1 = ipDiffim.KernelPcaD() # mean subtract 

47 imagePca2 = ipDiffim.KernelPcaD() # don't mean subtract 

48 kpv1 = ipDiffim.KernelPcaVisitorF(imagePca1) 

49 kpv2 = ipDiffim.KernelPcaVisitorF(imagePca2) 

50 

51 kRefIm = None 

52 

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 

58 

59 if kRefIm is None: 

60 kRefIm = kImage1 

61 

62 kImage1 = diffimTools.makePoissonNoiseImage(kImage1) 

63 kImage2 = afwImage.ImageD(kImage1, True) 

64 

65 imagePca1.addImage(kImage1, 1.0) 

66 imagePca2.addImage(kImage2, 1.0) 

67 

68 kpv1.subtractMean() 

69 

70 imagePca1.analyze() 

71 imagePca2.analyze() 

72 

73 pcaBasisList1 = kpv1.getEigenKernels() 

74 pcaBasisList2 = kpv2.getEigenKernels() 

75 

76 eVal1 = imagePca1.getEigenValues() 

77 eVal2 = imagePca2.getEigenValues() 

78 

79 # First term is far more signficant without mean subtraction 

80 self.assertGreater(eVal2[0], eVal1[0]) 

81 

82 # Last term basically zero with mean subtraction 

83 self.assertAlmostEqual(eVal1[-1], 0.0) 

84 

85 # Extra image with mean subtraction 

86 self.assertEqual(len(pcaBasisList1), (len(eVal1) + 1)) 

87 

88 # Same shape 

89 self.assertEqual(len(pcaBasisList2), len(eVal2)) 

90 

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) 

98 

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) 

108 

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) 

117 

118 imagePca = ipDiffim.KernelPcaD() 

119 kpv = ipDiffim.KernelPcaVisitorF(imagePca) 

120 kpv.processCandidate(kc1) 

121 kpv.processCandidate(kc2) 

122 kpv.processCandidate(kc3) 

123 

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])) 

130 

131 def testEigenValues(self): 

132 kc1 = self.makeCandidate(1, 0.0, 0.0) 

133 kc1.build(self.kList) 

134 

135 kc2 = self.makeCandidate(2, 0.0, 0.0) 

136 kc2.build(self.kList) 

137 

138 kc3 = self.makeCandidate(3, 0.0, 0.0) 

139 kc3.build(self.kList) 

140 

141 imagePca = ipDiffim.KernelPcaD() 

142 kpv = ipDiffim.KernelPcaVisitorF(imagePca) 

143 kpv.processCandidate(kc1) 

144 kpv.processCandidate(kc2) 

145 kpv.processCandidate(kc3) 

146 

147 imagePca.analyze() 

148 eigenImages = imagePca.getEigenImages() 

149 eigenValues = imagePca.getEigenValues() 

150 

151 # took in 3 images 

152 self.assertEqual(len(eigenImages), 3) 

153 self.assertEqual(len(eigenValues), 3) 

154 

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) 

159 

160 def testMeanSubtraction(self): 

161 kc1 = self.makeCandidate(1, 0.0, 0.0) 

162 kc1.build(self.kList) 

163 

164 kc2 = self.makeCandidate(2, 0.0, 0.0) 

165 kc2.build(self.kList) 

166 

167 kc3 = self.makeCandidate(3, 0.0, 0.0) 

168 kc3.build(self.kList) 

169 

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 

176 

177 imagePca.analyze() 

178 eigenImages = imagePca.getEigenImages() 

179 eigenValues = imagePca.getEigenValues() 

180 

181 # took in 3 images 

182 self.assertEqual(len(eigenImages), 3) 

183 self.assertEqual(len(eigenValues), 3) 

184 

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) 

189 

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) 

201 

202 def testVisit(self, nCell=3): 

203 imagePca = ipDiffim.KernelPcaD() 

204 kpv = ipDiffim.makeKernelPcaVisitor(imagePca) 

205 

206 sizeCellX = self.ps["sizeCellX"] 

207 sizeCellY = self.ps["sizeCellY"] 

208 

209 kernelCellSet = afwMath.SpatialCellSet(geom.Box2I(geom.Point2I(0, 0), 

210 geom.Extent2I(sizeCellX * nCell, 

211 sizeCellY * nCell)), 

212 sizeCellX, 

213 sizeCellY) 

214 

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) 

227 

228 kernelCellSet.visitCandidates(kpv, 1) 

229 imagePca.analyze() 

230 eigenImages = imagePca.getEigenImages() 

231 eigenValues = imagePca.getEigenValues() 

232 

233 # took in 3 images 

234 self.assertEqual(len(eigenImages), nCell * nCell) 

235 self.assertEqual(len(eigenValues), nCell * nCell) 

236 

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) 

241 

242##### 

243 

244 

245class TestMemory(lsst.utils.tests.MemoryTestCase): 

246 pass 

247 

248 

249def setup_module(module): 

250 lsst.utils.tests.init() 

251 

252 

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()