Coverage for tests/test_kernelSumVisitor.py: 21%

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

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

10import lsst.pex.config as pexConfig 

11 

12logUtils.traceSetAt("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()