Coverage for tests/test_kernelSumVisitor.py: 19%

98 statements  

« prev     ^ index     » next       coverage.py v7.5.0, created at 2024-05-03 03:35 -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.PsfMatchConfigDF() 

19 

20 self.ps = pexConfig.makePropertySet(self.config) 

21 self.kList = ipDiffim.makeKernelBasisList(self.config) 

22 

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

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

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

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

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

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

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

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

31 return kc 

32 

33 def tearDown(self): 

34 del self.ps 

35 del self.kList 

36 

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

38 ksv = ipDiffim.KernelSumVisitorF(self.ps) 

39 ksv.setMode(ipDiffim.KernelSumVisitorF.AGGREGATE) 

40 

41 # should fail, kernel not initialized 

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

43 try: 

44 ksv.processCandidate(kc) 

45 except Exception: 

46 pass 

47 else: 

48 self.fail() 

49 

50 for kSum in kSums: 

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

52 kc.build(self.kList) 

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

54 ksv.processCandidate(kc) 

55 

56 for method in (ksv.getNRejected, 

57 ksv.getkSumMean, 

58 ksv.getkSumStd, 

59 ksv.getdkSumMax, 

60 ksv.getkSumNpts): 

61 self.assertEqual(method(), 0.0) 

62 

63 ksv.processKsumDistribution() 

64 

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

66 self.assertAlmostEqual(ksv.getkSumMean(), 

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

68 self.assertAlmostEqual(ksv.getkSumStd(), 

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

70 self.assertEqual(ksv.getdkSumMax(), 

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

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

73 

74 def testReject(self): 

75 self.doReject(clipping=False) 

76 self.doReject(clipping=True) 

77 

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

79 self.ps["kernelSumClipping"] = clipping 

80 ksv = ipDiffim.KernelSumVisitorF(self.ps) 

81 ksv.setMode(ipDiffim.KernelSumVisitorF.AGGREGATE) 

82 kcList = [] 

83 

84 for kSum in kSums: 

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

86 kc.build(self.kList) 

87 kc.setStatus(afwMath.SpatialCellCandidate.GOOD) 

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

89 ksv.processCandidate(kc) 

90 kcList.append(kc) 

91 

92 ksv.processKsumDistribution() 

93 

94 ksv.setMode(ipDiffim.KernelSumVisitorF.REJECT) 

95 for kc in kcList: 

96 ksv.processCandidate(kc) 

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

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

99 else: 

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

101 

102 if clipping: 

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

104 else: 

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

106 

107 def testVisit(self, nCell=3): 

108 ksv = ipDiffim.makeKernelSumVisitor(self.ps) 

109 

110 sizeCellX = self.ps["sizeCellX"] 

111 sizeCellY = self.ps["sizeCellY"] 

112 

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

114 geom.Extent2I(sizeCellX * nCell, 

115 sizeCellY * nCell)), 

116 sizeCellX, 

117 sizeCellY) 

118 

119 for candX in range(nCell): 

120 for candY in range(nCell): 

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

122 kc = self.makeCandidate(100.0, 

123 candX * sizeCellX + sizeCellX // 2, 

124 candY * sizeCellY + sizeCellY // 2) 

125 else: 

126 kc = self.makeCandidate(1.0, 

127 candX * sizeCellX + sizeCellX // 2, 

128 candY * sizeCellY + sizeCellY // 2) 

129 kc.build(self.kList) 

130 kernelCellSet.insertCandidate(kc) 

131 

132 ksv.setMode(ipDiffim.KernelSumVisitorF.AGGREGATE) 

133 kernelCellSet.visitCandidates(ksv, 1) 

134 ksv.processKsumDistribution() 

135 ksv.setMode(ipDiffim.KernelSumVisitorF.REJECT) 

136 kernelCellSet.visitCandidates(ksv, 1) 

137 

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

139 

140##### 

141 

142 

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

144 pass 

145 

146 

147def setup_module(module): 

148 lsst.utils.tests.init() 

149 

150 

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

152 lsst.utils.tests.init() 

153 unittest.main()