Coverage for tests/test_kernelSumVisitor.py: 21%

100 statements  

« prev     ^ index     » next       coverage.py v6.4.2, created at 2022-07-27 02:32 -0700

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

10import lsst.pex.config as pexConfig 

11 

12logUtils.trace_set_at("lsst.ip.diffim", 2) 

13 

14 

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

16 

17 def setUp(self): 

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

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

20 self.subconfig = self.config.kernel.active 

21 

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

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

24 

25 def makeCandidate(self, kSum, x, y, size=51): 

26 mi1 = afwImage.MaskedImageF(geom.Extent2I(size, size)) 

27 mi1.getVariance().set(1.0) # avoid NaNs 

28 mi1[size//2, size//2, afwImage.LOCAL] = (1, 0x0, 1) 

29 mi2 = afwImage.MaskedImageF(geom.Extent2I(size, size)) 

30 mi2.getVariance().set(1.0) # avoid NaNs 

31 mi2[size//2, size//2, afwImage.LOCAL] = (kSum, 0x0, kSum) 

32 kc = ipDiffim.makeKernelCandidate(x, y, mi1, mi2, self.ps) 

33 return kc 

34 

35 def tearDown(self): 

36 del self.ps 

37 del self.kList 

38 

39 def testAggregate(self, kSums=[1., 1., 1., 1., 2., 3., 4.]): 

40 ksv = ipDiffim.KernelSumVisitorF(self.ps) 

41 ksv.setMode(ipDiffim.KernelSumVisitorF.AGGREGATE) 

42 

43 # should fail, kernel not initialized 

44 kc = self.makeCandidate(1, 0.0, 0.0) 

45 try: 

46 ksv.processCandidate(kc) 

47 except Exception: 

48 pass 

49 else: 

50 self.fail() 

51 

52 for kSum in kSums: 

53 kc = self.makeCandidate(kSum, 0., 0.) 

54 kc.build(self.kList) 

55 self.assertAlmostEqual(kSum, kc.getKsum(ipDiffim.KernelCandidateF.RECENT)) 

56 ksv.processCandidate(kc) 

57 

58 for method in (ksv.getNRejected, 

59 ksv.getkSumMean, 

60 ksv.getkSumStd, 

61 ksv.getdkSumMax, 

62 ksv.getkSumNpts): 

63 self.assertEqual(method(), 0.0) 

64 

65 ksv.processKsumDistribution() 

66 

67 self.assertEqual(ksv.getNRejected(), 0) 

68 self.assertAlmostEqual(ksv.getkSumMean(), 

69 afwMath.makeStatistics(kSums, afwMath.MEANCLIP).getValue(afwMath.MEANCLIP)) 

70 self.assertAlmostEqual(ksv.getkSumStd(), 

71 afwMath.makeStatistics(kSums, afwMath.STDEVCLIP).getValue(afwMath.STDEVCLIP)) 

72 self.assertEqual(ksv.getdkSumMax(), 

73 self.ps["maxKsumSigma"] * ksv.getkSumStd()) 

74 self.assertEqual(ksv.getkSumNpts(), len(kSums)) 

75 

76 def testReject(self): 

77 self.doReject(clipping=False) 

78 self.doReject(clipping=True) 

79 

80 def doReject(self, clipping, kSums=[1., 1., 1., 1., 2., 3., 4., 50.]): 

81 self.ps["kernelSumClipping"] = clipping 

82 ksv = ipDiffim.KernelSumVisitorF(self.ps) 

83 ksv.setMode(ipDiffim.KernelSumVisitorF.AGGREGATE) 

84 kcList = [] 

85 

86 for kSum in kSums: 

87 kc = self.makeCandidate(kSum, 0., 0.) 

88 kc.build(self.kList) 

89 kc.setStatus(afwMath.SpatialCellCandidate.GOOD) 

90 self.assertAlmostEqual(kSum, kc.getKsum(ipDiffim.KernelCandidateF.RECENT)) 

91 ksv.processCandidate(kc) 

92 kcList.append(kc) 

93 

94 ksv.processKsumDistribution() 

95 

96 ksv.setMode(ipDiffim.KernelSumVisitorF.REJECT) 

97 for kc in kcList: 

98 ksv.processCandidate(kc) 

99 if clipping and kc == kcList[-1]: 

100 self.assertEqual(kc.getStatus(), afwMath.SpatialCellCandidate.BAD) 

101 else: 

102 self.assertEqual(kc.getStatus(), afwMath.SpatialCellCandidate.GOOD) 

103 

104 if clipping: 

105 self.assertEqual(ksv.getNRejected(), 1) 

106 else: 

107 self.assertEqual(ksv.getNRejected(), 0) 

108 

109 def testVisit(self, nCell=3): 

110 ksv = ipDiffim.makeKernelSumVisitor(self.ps) 

111 

112 sizeCellX = self.ps["sizeCellX"] 

113 sizeCellY = self.ps["sizeCellY"] 

114 

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

116 geom.Extent2I(sizeCellX * nCell, 

117 sizeCellY * nCell)), 

118 sizeCellX, 

119 sizeCellY) 

120 

121 for candX in range(nCell): 

122 for candY in range(nCell): 

123 if candX == nCell // 2 and candY == nCell // 2: 

124 kc = self.makeCandidate(100.0, 

125 candX * sizeCellX + sizeCellX // 2, 

126 candY * sizeCellY + sizeCellY // 2) 

127 else: 

128 kc = self.makeCandidate(1.0, 

129 candX * sizeCellX + sizeCellX // 2, 

130 candY * sizeCellY + sizeCellY // 2) 

131 kc.build(self.kList) 

132 kernelCellSet.insertCandidate(kc) 

133 

134 ksv.setMode(ipDiffim.KernelSumVisitorF.AGGREGATE) 

135 kernelCellSet.visitCandidates(ksv, 1) 

136 ksv.processKsumDistribution() 

137 ksv.setMode(ipDiffim.KernelSumVisitorF.REJECT) 

138 kernelCellSet.visitCandidates(ksv, 1) 

139 

140 self.assertEqual(ksv.getNRejected(), 1) 

141 

142##### 

143 

144 

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

146 pass 

147 

148 

149def setup_module(module): 

150 lsst.utils.tests.init() 

151 

152 

153if __name__ == "__main__": 153 ↛ 154line 153 didn't jump to line 154, because the condition on line 153 was never true

154 lsst.utils.tests.init() 

155 unittest.main()