Coverage for tests/test_assessSpatialKernelVisitor.py: 21%

98 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2023-02-16 03:29 -0800

1import unittest 

2import numpy as num 

3 

4 

5import lsst.utils.tests 

6import lsst.afw.image as afwImage 

7import lsst.afw.math as afwMath 

8import lsst.geom as geom 

9import lsst.ip.diffim as ipDiffim 

10import lsst.utils.logging as logUtils 

11import lsst.pex.config as pexConfig 

12 

13# Increase the number for more verbose messages; decrease for fewer messages 

14logUtils.trace_set_at("lsst.ip.diffim", 4) 

15 

16 

17class DiffimTestCases(unittest.TestCase): 

18 

19 def setUp(self): 

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

21 self.config.kernel.name = "AL" 

22 self.subconfig = self.config.kernel.active 

23 

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

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

26 

27 self.ksize = self.ps['kernelSize'] 

28 

29 def makeSpatialKernel(self, order): 

30 basicGaussian1 = afwMath.GaussianFunction2D(2., 2., 0.) 

31 basicKernel1 = afwMath.AnalyticKernel(self.ksize, self.ksize, basicGaussian1) 

32 

33 basicGaussian2 = afwMath.GaussianFunction2D(5., 3., 0.5 * num.pi) 

34 basicKernel2 = afwMath.AnalyticKernel(self.ksize, self.ksize, basicGaussian2) 

35 

36 basisList = [] 

37 basisList.append(basicKernel1) 

38 basisList.append(basicKernel2) 

39 basisList = ipDiffim.renormalizeKernelList(basisList) 

40 

41 spatialKernelFunction = afwMath.PolynomialFunction2D(order) 

42 spatialKernel = afwMath.LinearCombinationKernel(basisList, spatialKernelFunction) 

43 kCoeffs = [[0.0 for x in range(1, spatialKernelFunction.getNParameters()+1)], 

44 [0.01 * x for x in range(1, spatialKernelFunction.getNParameters()+1)]] 

45 kCoeffs[0][0] = 1.0 # it does not vary spatially; constant across image 

46 spatialKernel.setSpatialParameters(kCoeffs) 

47 return spatialKernel 

48 

49 def tearDown(self): 

50 del self.ps 

51 del self.kList 

52 

53 def testGood(self): 

54 ti = afwImage.MaskedImageF(geom.Extent2I(100, 100)) 

55 ti.getVariance().set(0.1) 

56 ti[50, 50, afwImage.LOCAL] = (1., 0x0, 1.) 

57 sKernel = self.makeSpatialKernel(2) 

58 si = afwImage.MaskedImageF(ti.getDimensions()) 

59 convolutionControl = afwMath.ConvolutionControl() 

60 convolutionControl.setDoNormalize(True) 

61 afwMath.convolve(si, ti, sKernel, convolutionControl) 

62 

63 bbox = geom.Box2I(geom.Point2I(25, 25), 

64 geom.Point2I(75, 75)) 

65 si = afwImage.MaskedImageF(si, bbox, origin=afwImage.LOCAL) 

66 ti = afwImage.MaskedImageF(ti, bbox, origin=afwImage.LOCAL) 

67 kc = ipDiffim.KernelCandidateF(50., 50., ti, si, self.ps) 

68 

69 sBg = afwMath.PolynomialFunction2D(1) 

70 bgCoeffs = [0., 0., 0.] 

71 sBg.setParameters(bgCoeffs) 

72 

73 # must be initialized 

74 bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps) 

75 bskv.processCandidate(kc) 

76 self.assertEqual(kc.isInitialized(), True) 

77 

78 askv = ipDiffim.AssessSpatialKernelVisitorF(sKernel, sBg, self.ps) 

79 askv.processCandidate(kc) 

80 

81 self.assertEqual(askv.getNProcessed(), 1) 

82 self.assertEqual(askv.getNRejected(), 0) 

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

84 

85 def testBad(self): 

86 ti = afwImage.MaskedImageF(geom.Extent2I(100, 100)) 

87 ti.getVariance().set(0.1) 

88 ti[50, 50, afwImage.LOCAL] = (1., 0x0, 1.) 

89 sKernel = self.makeSpatialKernel(2) 

90 si = afwImage.MaskedImageF(ti.getDimensions()) 

91 convolutionControl = afwMath.ConvolutionControl() 

92 convolutionControl.setDoNormalize(True) 

93 afwMath.convolve(si, ti, sKernel, convolutionControl) 

94 

95 bbox = geom.Box2I(geom.Point2I(25, 25), 

96 geom.Point2I(75, 75)) 

97 si = afwImage.MaskedImageF(si, bbox, origin=afwImage.LOCAL) 

98 ti = afwImage.MaskedImageF(ti, bbox, origin=afwImage.LOCAL) 

99 kc = ipDiffim.KernelCandidateF(50., 50., ti, si, self.ps) 

100 

101 badGaussian = afwMath.GaussianFunction2D(1., 1., 0.) 

102 badKernel = afwMath.AnalyticKernel(self.ksize, self.ksize, badGaussian) 

103 basisList = [] 

104 basisList.append(badKernel) 

105 badSpatialKernelFunction = afwMath.PolynomialFunction2D(0) 

106 badSpatialKernel = afwMath.LinearCombinationKernel(basisList, badSpatialKernelFunction) 

107 badSpatialKernel.setSpatialParameters([[1, ]]) 

108 

109 sBg = afwMath.PolynomialFunction2D(1) 

110 bgCoeffs = [10., 10., 10.] 

111 sBg.setParameters(bgCoeffs) 

112 

113 # must be initialized 

114 bskv = ipDiffim.BuildSingleKernelVisitorF(self.kList, self.ps) 

115 bskv.processCandidate(kc) 

116 self.assertEqual(kc.isInitialized(), True) 

117 

118 askv = ipDiffim.AssessSpatialKernelVisitorF(badSpatialKernel, sBg, self.ps) 

119 askv.processCandidate(kc) 

120 

121 self.assertEqual(askv.getNProcessed(), 1) 

122 self.assertEqual(askv.getNRejected(), 1) 

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

124 

125 

126##### 

127 

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

129 pass 

130 

131 

132def setup_module(module): 

133 lsst.utils.tests.init() 

134 

135 

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

137 lsst.utils.tests.init() 

138 unittest.main()