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("GLOBAL_REDUCED_CHI_SQUARED", rng.random()) 

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

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

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

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

70 self.metadatas.append(metadata) 

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

72 brightStarStamps.append(brightStarStamp) 

73 self.primary_metadata = PropertyList() 

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

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

76 

77 def tearDown(self): 

78 del self.brightStarStamps 

79 del self.metadatas 

80 del self.primary_metadata 

81 

82 def testBrightStarStamps(self): 

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

84 

85 with NamedTemporaryFile() as file: 

86 self.brightStarStamps.writeFits(file.name) 

87 # Test StampsBase correctly bounces to BrightStarStamps readFits 

88 brightStarStamps = StampsBase.readFits(file.name) 

89 

90 primary_metadata = brightStarStamps.metadata 

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

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

93 for input_metadata, input_stamp, output_stamp in zip( 

94 self.metadatas, self.brightStarStamps, brightStarStamps 

95 ): 

96 output_metadata = output_stamp.metadata 

97 for key in output_metadata.names(): 

98 input_value = input_metadata[key] 

99 output_value = output_metadata[key] 

100 if isinstance(input_value, float): 

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

102 else: 

103 self.assertEqual(input_value, output_value) 

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

105 

106 

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

108 pass 

109 

110 

111def setup_module(module): 

112 lsst.utils.tests.init() 

113 

114 

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

116 lsst.utils.tests.init() 

117 unittest.main()