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

57 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2023-04-13 02:49 -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/>. 

21import numpy as np 

22 

23from lsst.utils import TemplateMeta 

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

25 

26from ..image._fitsIoWithOptions import imageReadFitsWithOptions, exposureWriteFitsWithOptions 

27from ..image._slicing import supportSlicing 

28from ..image._disableArithmetic import disableImageArithmetic 

29 

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

31 

32 

33VariancePixel = np.float32 

34 

35 

36class MaskedImage(metaclass=TemplateMeta): 

37 

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

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

40 """ 

41 if mask is None and variance is None: 

42 try: 

43 value, mask, variance = value 

44 except TypeError: 

45 pass 

46 if mask is None: 

47 mask = 0 

48 if variance is None: 

49 variance = 0.0 

50 self.image.set(value) 

51 self.mask.set(mask) 

52 self.variance.set(variance) 

53 

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

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

56 

57 Parameters 

58 ---------- 

59 index : `geom.Point2I` 

60 Position of the pixel to assign to. 

61 value : `tuple` 

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

63 origin : `ImageOrigin` 

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

65 """ 

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

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

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

69 

70 def _get(self, index, origin): 

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

72 

73 Parameters 

74 ---------- 

75 index : `geom.Point2I` 

76 Position of the pixel to assign to. 

77 origin : `ImageOrigin` 

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

79 """ 

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

81 self.mask[index, origin], 

82 self.variance[index, origin]) 

83 

84 def getArrays(self): 

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

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

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

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

89 

90 def convertF(self): 

91 return MaskedImageF(self, True) 

92 

93 def convertD(self): 

94 return MaskedImageD(self, True) 

95 

96 def __reduce__(self): 

97 from lsst.afw.fits import reduceToFits 

98 return reduceToFits(self) 

99 

100 def __str__(self): 

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

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

103 self.mask.array, 

104 self.mask.getMaskPlaneDict(), 

105 self.variance.array, 

106 self.getBBox()) 

107 

108 def __repr__(self): 

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

110 

111 readFitsWithOptions = classmethod(imageReadFitsWithOptions) 

112 

113 writeFitsWithOptions = exposureWriteFitsWithOptions 

114 

115 

116MaskedImage.register(np.int32, MaskedImageI) 

117MaskedImage.register(np.float32, MaskedImageF) 

118MaskedImage.register(np.float64, MaskedImageD) 

119MaskedImage.register(np.uint16, MaskedImageU) 

120MaskedImage.register(np.uint64, MaskedImageL) 

121MaskedImage.alias("I", MaskedImageI) 

122MaskedImage.alias("F", MaskedImageF) 

123MaskedImage.alias("D", MaskedImageD) 

124MaskedImage.alias("U", MaskedImageU) 

125MaskedImage.alias("L", MaskedImageL) 

126 

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

128 supportSlicing(cls) 

129 disableImageArithmetic(cls)