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

61 statements  

« prev     ^ index     » next       coverage.py v7.4.4, created at 2024-03-23 03:25 -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 

22from deprecated.sphinx import deprecated 

23 

24import numpy as np 

25 

26from lsst.utils import TemplateMeta 

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

28 

29from .._image._fitsIoWithOptions import imageReadFitsWithOptions, exposureWriteFitsWithOptions 

30from .._image._slicing import supportSlicing 

31from .._image._disableArithmetic import disableImageArithmetic 

32 

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

34 

35 

36VariancePixel = np.float32 

37 

38 

39class MaskedImage(metaclass=TemplateMeta): 

40 

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

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

43 """ 

44 if mask is None and variance is None: 

45 try: 

46 value, mask, variance = value 

47 except TypeError: 

48 pass 

49 if mask is None: 

50 mask = 0 

51 if variance is None: 

52 variance = 0.0 

53 self.image.set(value) 

54 self.mask.set(mask) 

55 self.variance.set(variance) 

56 

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

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

59 

60 Parameters 

61 ---------- 

62 index : `geom.Point2I` 

63 Position of the pixel to assign to. 

64 value : `tuple` 

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

66 origin : `ImageOrigin` 

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

68 """ 

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

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

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

72 

73 def _get(self, index, origin): 

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

75 

76 Parameters 

77 ---------- 

78 index : `geom.Point2I` 

79 Position of the pixel to assign to. 

80 origin : `ImageOrigin` 

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

82 """ 

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

84 self.mask[index, origin], 

85 self.variance[index, origin]) 

86 

87 @deprecated(reason=("This method is being removed in favor of the individual properties." 

88 " It will be removed after v26."), 

89 version="v26.0", category=FutureWarning) 

90 def getArrays(self): 

91 """Return a tuple (value, mask, variance) numpy arrays.""" 

92 return (self.image.array if self.image else None, 

93 self.mask.array if self.mask else None, 

94 self.variance.array if self.variance else None) 

95 

96 def convertF(self): 

97 return MaskedImageF(self, True) 

98 

99 def convertD(self): 

100 return MaskedImageD(self, True) 

101 

102 def __reduce__(self): 

103 from lsst.afw.fits import reduceToFits 

104 return reduceToFits(self) 

105 

106 def __deepcopy__(self, memo=None): 

107 return self.clone() 

108 

109 def __str__(self): 

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

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

112 self.mask.array, 

113 self.mask.getMaskPlaneDict(), 

114 self.variance.array, 

115 self.getBBox()) 

116 

117 def __repr__(self): 

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

119 

120 readFitsWithOptions = classmethod(imageReadFitsWithOptions) 

121 

122 writeFitsWithOptions = exposureWriteFitsWithOptions 

123 

124 

125MaskedImage.register(np.int32, MaskedImageI) 

126MaskedImage.register(np.float32, MaskedImageF) 

127MaskedImage.register(np.float64, MaskedImageD) 

128MaskedImage.register(np.uint16, MaskedImageU) 

129MaskedImage.register(np.uint64, MaskedImageL) 

130MaskedImage.alias("I", MaskedImageI) 

131MaskedImage.alias("F", MaskedImageF) 

132MaskedImage.alias("D", MaskedImageD) 

133MaskedImage.alias("U", MaskedImageU) 

134MaskedImage.alias("L", MaskedImageL) 

135 

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

137 supportSlicing(cls) 

138 disableImageArithmetic(cls)