Coverage for tests / test_brightStarStamps.py: 20%

1# This file is part of meas_algorithms. 

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 

23from tempfile import NamedTemporaryFile 

24 

25import lsst.utils.tests 

26import numpy as np 

27from lsst.afw.image import MaskedImageF 

28from lsst.daf.base import PropertyList 

29from lsst.meas.algorithms import BrightStarStamp, BrightStarStamps 

30from lsst.meas.algorithms.stamps import StampsBase 

31 

32 

33class BrightStarStampsTestCase(lsst.utils.tests.TestCase): 

34 """Test BrightStarStamps.""" 

35 

36 def setUp(self): 

37 rng = np.random.Generator(np.random.MT19937(seed=5)) 

38 stamp_size = (25, 25) 

39 

40 # Generate simulated bright star stamps 

41 brightStarStamps = [] 

42 self.metadatas = [] 

43 for i in range(3): 

44 stamp = MaskedImageF(*stamp_size) 

45 stamp_array = stamp.image.array 

46 stamp_array += rng.random(stamp_size) 

47 psf = None 

48 wcs = None 

49 metadata = PropertyList() 

50 metadata.set("VISIT", i) 

51 metadata.set("DETECTOR", i + 1) 

52 metadata.set("REF_ID", f"ref{i}") 

53 metadata.set("REF_MAG", float(i * 5)) 

54 metadata.set("POSITION_X", rng.random()) 

55 metadata.set("POSITION_Y", rng.random()) 

56 metadata.set("FOCAL_PLANE_RADIUS", rng.random()) 

57 metadata.set("FOCAL_PLANE_ANGLE_DEGREES", rng.random()) 

58 metadata.set("SCALE", rng.random()) 

59 metadata.set("SCALE_ERR", rng.random()) 

60 metadata.set("PEDESTAL", rng.random()) 

61 metadata.set("PEDESTAL_ERR", rng.random()) 

62 metadata.set("PEDESTAL_SCALE_COV", rng.random()) 

63 metadata.set("GRADIENT_X", rng.random()) 

64 metadata.set("GRADIENT_Y", rng.random()) 

65 metadata.set("CURVATURE_X", rng.random()) 

66 metadata.set("CURVATURE_Y", rng.random()) 

67 metadata.set("CURVATURE_XY", rng.random()) 

68 metadata.set("GLOBAL_REDUCED_CHI_SQUARED", rng.random()) 

69 metadata.set("GLOBAL_DEGREES_OF_FREEDOM", rng.integers(1, 100)) 

70 metadata.set("PSF_REDUCED_CHI_SQUARED", rng.random()) 

71 metadata.set("PSF_DEGREES_OF_FREEDOM", rng.integers(1, 100)) 

72 metadata.set("PSF_MASKED_FLUX_FRACTION", rng.random()) 

73 self.metadatas.append(metadata) 

74 brightStarStamp = BrightStarStamp.factory(stamp, psf, wcs, metadata) 

75 brightStarStamps.append(brightStarStamp) 

76 self.primary_metadata = PropertyList() 

77 self.primary_metadata.set("TEST_KEY", "TEST VALUE") 

78 self.brightStarStamps = BrightStarStamps(brightStarStamps, self.primary_metadata) 

79 

80 def tearDown(self): 

81 del self.brightStarStamps 

82 del self.metadatas 

83 del self.primary_metadata 

84 

85 def testBrightStarStamps(self): 

86 """Test that BrightStarStamps can be serialized and deserialized.""" 

87 

88 with NamedTemporaryFile() as file: 

89 self.brightStarStamps.writeFits(file.name) 

90 # Test StampsBase correctly bounces to BrightStarStamps readFits 

91 brightStarStamps = StampsBase.readFits(file.name) 

92 

93 primary_metadata = brightStarStamps.metadata 

94 self.assertEqual(self.primary_metadata["TEST_KEY"], primary_metadata["TEST_KEY"]) 

95 self.assertEqual(len(self.metadatas), primary_metadata["N_STAMPS"]) 

96 for input_metadata, input_stamp, output_stamp in zip( 

97 self.metadatas, self.brightStarStamps, brightStarStamps 

98 ): 

99 output_metadata = output_stamp.metadata 

100 for key in output_metadata.names(): 

101 input_value = input_metadata[key] 

102 output_value = output_metadata[key] 

103 if isinstance(input_value, float): 

104 self.assertAlmostEqual(input_value, output_value, places=10) 

105 else: 

106 self.assertEqual(input_value, output_value) 

107 self.assertMaskedImagesAlmostEqual(input_stamp.stamp_im, output_stamp.stamp_im) 

108 

109 

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

111 pass 

112 

113 

114def setup_module(module): 

115 lsst.utils.tests.init() 

116 

117 

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

119 lsst.utils.tests.init() 

120 unittest.main()