Coverage for python/lsst/afw/image/_maskedImage/_maskedImageContinued.py: 54%

57 statements  

« prev     ^ index     » next       coverage.py v7.5.0, created at 2024-05-01 03:31 -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 numpy as np 

23 

24from lsst.utils import TemplateMeta 

25from ._maskedImage import MaskedImageI, MaskedImageF, MaskedImageD, MaskedImageU, MaskedImageL 

26 

27from .._image._fitsIoWithOptions import imageReadFitsWithOptions, exposureWriteFitsWithOptions 

28from .._image._slicing import supportSlicing 

29from .._image._disableArithmetic import disableImageArithmetic 

30 

31__all__ = ["MaskedImage", "VariancePixel"] 

32 

33 

34VariancePixel = np.float32 

35 

36 

37class MaskedImage(metaclass=TemplateMeta): 

38 

39 def set(self, value, mask=None, variance=None): 

40 """Assign a tuple of scalars to the entirety of all three planes. 

41 """ 

42 if mask is None and variance is None: 

43 try: 

44 value, mask, variance = value 

45 except TypeError: 

46 pass 

47 if mask is None: 

48 mask = 0 

49 if variance is None: 

50 variance = 0.0 

51 self.image.set(value) 

52 self.mask.set(mask) 

53 self.variance.set(variance) 

54 

55 def _set(self, index, value, origin): 

56 """Set the pixel at the given index to a triple (value, mask, variance). 

57 

58 Parameters 

59 ---------- 

60 index : `geom.Point2I` 

61 Position of the pixel to assign to. 

62 value : `tuple` 

63 A tuple of (value, mask, variance) scalars. 

64 origin : `ImageOrigin` 

65 Coordinate system of ``index`` (`PARENT` or `LOCAL`). 

66 """ 

67 self.image[index, origin] = value[0] 

68 self.mask[index, origin] = value[1] 

69 self.variance[index, origin] = value[2] 

70 

71 def _get(self, index, origin): 

72 """Return a triple (value, mask, variance) at the given index. 

73 

74 Parameters 

75 ---------- 

76 index : `geom.Point2I` 

77 Position of the pixel to assign to. 

78 origin : `ImageOrigin` 

79 Coordinate system of ``index`` (`PARENT` or `LOCAL`). 

80 """ 

81 return (self.image[index, origin], 

82 self.mask[index, origin], 

83 self.variance[index, origin]) 

84 

85 def convertF(self): 

86 return MaskedImageF(self, True) 

87 

88 def convertD(self): 

89 return MaskedImageD(self, True) 

90 

91 def __reduce__(self): 

92 from lsst.afw.fits import reduceToFits 

93 return reduceToFits(self) 

94 

95 def __deepcopy__(self, memo=None): 

96 return self.clone() 

97 

98 def __str__(self): 

99 string = "image={},\nmask={}, maskPlaneDict={}\nvariance={}, bbox={}" 

100 return string.format(self.image.array, 

101 self.mask.array, 

102 self.mask.getMaskPlaneDict(), 

103 self.variance.array, 

104 self.getBBox()) 

105 

106 def __repr__(self): 

107 return "{}.{}=({})".format(self.__module__, self.__class__.__name__, str(self)) 

108 

109 readFitsWithOptions = classmethod(imageReadFitsWithOptions) 

110 

111 writeFitsWithOptions = exposureWriteFitsWithOptions 

112 

113 

114MaskedImage.register(np.int32, MaskedImageI) 

115MaskedImage.register(np.float32, MaskedImageF) 

116MaskedImage.register(np.float64, MaskedImageD) 

117MaskedImage.register(np.uint16, MaskedImageU) 

118MaskedImage.register(np.uint64, MaskedImageL) 

119MaskedImage.alias("I", MaskedImageI) 

120MaskedImage.alias("F", MaskedImageF) 

121MaskedImage.alias("D", MaskedImageD) 

122MaskedImage.alias("U", MaskedImageU) 

123MaskedImage.alias("L", MaskedImageL) 

124 

125for cls in set(MaskedImage.values()): 

126 supportSlicing(cls) 

127 disableImageArithmetic(cls)