Coverage for tests/test_color.py: 25%

123 statements  

« prev     ^ index     » next       coverage.py v6.4, created at 2022-05-24 02:38 -0700

1# This file is part of afw. 

2# 

3# Developed for the LSST Data Management System. 

4# This product includes software developed by the LSST Project 

5# (https://www.lsst.org). 

6# See the COPYRIGHT file at the top-level directory of this distribution 

7# for details of code ownership. 

8# 

9# This program is free software: you can redistribute it and/or modify 

10# it under the terms of the GNU General Public License as published by 

11# the Free Software Foundation, either version 3 of the License, or 

12# (at your option) any later version. 

13# 

14# This program is distributed in the hope that it will be useful, 

15# but WITHOUT ANY WARRANTY; without even the implied warranty of 

16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

17# GNU General Public License for more details. 

18# 

19# You should have received a copy of the GNU General Public License 

20# along with this program. If not, see <https://www.gnu.org/licenses/>. 

21 

22import unittest 

23 

24import numpy as np 

25 

26import lsst.utils.tests 

27import lsst.daf.base as dafBase 

28import lsst.pex.exceptions as pexExcept 

29import lsst.afw.image as afwImage 

30import lsst.afw.image.utils as imageUtils 

31 

32 

33def defineSdssFilters(testCase): 

34 """Initialise filters as used for our tests""" 

35 imageUtils.resetFilters() 

36 wavelengths = dict() 

37 testCase.aliases = dict(u=[], g=[], r=[], i=[], z=['zprime', "z'"]) 

38 for name, lambdaEff in (('u', 355.1), 

39 ('g', 468.6), 

40 ('r', 616.5), 

41 ('i', 748.1), 

42 ('z', 893.1)): 

43 wavelengths[name] = lambdaEff 

44 imageUtils.defineFilter(name, lambdaEff, alias=testCase.aliases[name]) 

45 return wavelengths 

46 

47 

48class ColorTestCase(lsst.utils.tests.TestCase): 

49 def setUp(self): 

50 defineSdssFilters(self) 

51 

52 def testCtor(self): 

53 afwImage.Color() 

54 afwImage.Color(1.2) 

55 

56 def testLambdaEff(self): 

57 f = afwImage.Filter("g") 

58 g_r = 1.2 

59 c = afwImage.Color(g_r) 

60 

61 # XXX Not a real implementation! 

62 self.assertEqual(c.getLambdaEff(f), 1000*g_r) 

63 

64 def testIsIndeterminate(self): 

65 """Test that a default-constructed Color tests True, but ones with a g-r value test False""" 

66 self.assertTrue(afwImage.Color().isIndeterminate()) 

67 self.assertFalse(afwImage.Color(1.2).isIndeterminate()) 

68 

69 

70class FilterTestCase(lsst.utils.tests.TestCase): 

71 def setUp(self): 

72 # Initialise our filters 

73 # Start by forgetting that we may already have defined filters 

74 wavelengths = defineSdssFilters(self) 

75 self.filters = tuple(sorted(wavelengths.keys())) 

76 self.g_lambdaEff = [lambdaEff for name, 

77 lambdaEff in wavelengths.items() if name == "g"][0] # for tests 

78 

79 def defineFilterProperty(self, name, lambdaEff, force=False): 

80 return afwImage.FilterProperty(name, lambdaEff, force=force) 

81 

82 def testListFilters(self): 

83 self.assertEqual(afwImage.Filter.getNames(), list(self.filters)) 

84 

85 def testCtorFromMetadata(self): 

86 """Test building a Filter from metadata""" 

87 

88 metadata = dafBase.PropertySet() 

89 metadata.add("FILTER", "g") 

90 

91 f = afwImage.Filter(metadata) 

92 self.assertEqual(f.getName(), "g") 

93 # Check that we can clean up metadata 

94 afwImage.stripFilterKeywords(metadata) 

95 self.assertEqual(len(metadata.names()), 0) 

96 

97 badFilter = "rhl" # an undefined filter 

98 metadata.add("FILTER", badFilter) 

99 # Not defined 

100 with self.assertRaises(pexExcept.NotFoundError): 

101 afwImage.Filter(metadata) 

102 

103 # Force definition 

104 f = afwImage.Filter(metadata, True) 

105 self.assertEqual(f.getName(), badFilter) # name is correctly defined 

106 

107 def testFilterEquality(self): 

108 """Test a "g" filter comparison""" 

109 f = afwImage.Filter("g") 

110 g = afwImage.Filter("g") 

111 

112 self.assertEqual(f, g) 

113 

114 f = afwImage.Filter() # the unknown filter 

115 self.assertNotEqual(f, f) # ... doesn't equal itself 

116 

117 def testFilterProperty(self): 

118 """Test properties of a "g" filter""" 

119 f = afwImage.Filter("g") 

120 # The properties of a g filter 

121 g = afwImage.FilterProperty.lookup("g") 

122 

123 self.assertEqual(f.getName(), "g") 

124 self.assertEqual(f.getId(), 1) 

125 self.assertEqual(f.getFilterProperty().getLambdaEff(), 

126 self.g_lambdaEff) 

127 self.assertEqual(f.getFilterProperty(), 

128 self.defineFilterProperty("gX", self.g_lambdaEff, force=True)) 

129 self.assertEqual(g.getLambdaEff(), self.g_lambdaEff) 

130 

131 def testLambdaMinMax(self): 

132 """Test additional properties for minimum and maximum wavelength for a filter.""" 

133 filt = afwImage.Filter("g") 

134 # LambdaMin and LambdaMax are undefined for the test SDSS filter, and should return nan 

135 self.assertTrue(np.isnan(filt.getFilterProperty().getLambdaMin())) 

136 self.assertTrue(np.isnan(filt.getFilterProperty().getLambdaMax())) 

137 lambdaEff = 476.31 

138 lambdaMin = 405 

139 lambdaMax = 552 

140 imageUtils.defineFilter("gNew", lambdaEff, lambdaMin=lambdaMin, lambdaMax=lambdaMax) 

141 filtNew = afwImage.Filter("gNew") 

142 self.assertEqual(lambdaMin, filtNew.getFilterProperty().getLambdaMin()) 

143 self.assertEqual(lambdaMax, filtNew.getFilterProperty().getLambdaMax()) 

144 

145 def testFilterAliases(self): 

146 """Test that we can provide an alias for a Filter""" 

147 for name0 in self.aliases: 

148 f0 = afwImage.Filter(name0) 

149 self.assertEqual(f0.getCanonicalName(), name0) 

150 self.assertEqual(sorted(f0.getAliases()), 

151 sorted(self.aliases[name0])) 

152 

153 for name in self.aliases[name0]: 

154 f = afwImage.Filter(name) 

155 self.assertEqual(sorted(f.getAliases()), 

156 sorted(self.aliases[name0])) 

157 self.assertEqual(f.getId(), f0.getId()) 

158 self.assertEqual(f.getName(), name) 

159 self.assertEqual(afwImage.Filter(f.getId()).getName(), name0) 

160 self.assertEqual(f.getCanonicalName(), name0) 

161 self.assertNotEqual(f.getCanonicalName(), name) 

162 self.assertEqual(f.getFilterProperty().getLambdaEff(), 

163 f0.getFilterProperty().getLambdaEff()) 

164 

165 def testReset(self): 

166 """Test that we can reset filter IDs and properties if needs be""" 

167 g = afwImage.FilterProperty.lookup("g") 

168 

169 # Can we add a filter property? 

170 with self.assertRaises(pexExcept.RuntimeError): 

171 self.defineFilterProperty("g", self.g_lambdaEff + 10) 

172 # should not raise 

173 self.defineFilterProperty("g", self.g_lambdaEff + 10, True) 

174 self.defineFilterProperty("g", self.g_lambdaEff, True) 

175 

176 # Can we redefine properties? 

177 with self.assertRaises(pexExcept.RuntimeError): 

178 # changing definition is not allowed 

179 self.defineFilterProperty("g", self.g_lambdaEff + 10) 

180 

181 # identical redefinition is allowed 

182 self.defineFilterProperty("g", self.g_lambdaEff) 

183 

184 # OK if Id's the same 

185 afwImage.Filter.define(g, afwImage.Filter("g").getId()) 

186 # AUTO will assign the same ID 

187 afwImage.Filter.define(g, afwImage.Filter.AUTO) 

188 

189 # different ID 

190 with self.assertRaises(pexExcept.RuntimeError): 

191 afwImage.Filter.define(g, afwImage.Filter("g").getId() + 10) 

192 

193 def testUnknownFilter(self): 

194 """Test that we can define, but not use, an unknown filter""" 

195 badFilter = "rhl" # an undefined filter 

196 with self.assertRaises(pexExcept.NotFoundError): 

197 afwImage.Filter(badFilter) 

198 # Force definition 

199 f = afwImage.Filter(badFilter, True) 

200 self.assertEqual(f.getName(), badFilter) # name is correctly defined 

201 

202 # can't use Filter f 

203 with self.assertRaises(pexExcept.NotFoundError): 

204 f.getFilterProperty().getLambdaEff() 

205 

206 # Now define badFilter 

207 lambdaEff = 666.0 

208 self.defineFilterProperty(badFilter, lambdaEff) 

209 

210 # but now we can 

211 self.assertEqual(f.getFilterProperty().getLambdaEff(), lambdaEff) 

212 

213 # Check that we didn't accidently define the unknown filter 

214 with self.assertRaises(pexExcept.NotFoundError): 

215 afwImage.Filter().getFilterProperty().getLambdaEff() 

216 

217 

218class MemoryTester(lsst.utils.tests.MemoryTestCase): 

219 pass 

220 

221 

222def setup_module(module): 

223 lsst.utils.tests.init() 

224 

225 

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

227 lsst.utils.tests.init() 

228 unittest.main()