Coverage for python/lsst/sphgeom/pixelization_abc.py: 73%

22 statements  

« prev     ^ index     » next       coverage.py v7.2.7, created at 2023-06-13 16:05 -0700

1# This file is part of sphgeom. 

2# 

3# Developed for the LSST Data Management System. 

4# This product includes software developed by the LSST Project 

5# (http://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 <http://www.gnu.org/licenses/>. 

21__all__ = ["PixelizationABC"] 

22 

23import abc 

24 

25from ._sphgeom import RangeSet, Region, UnitVector3d 

26 

27 

28class PixelizationABC(abc.ABC): 

29 """Pixelization ABC class that should be a base for 

30 Python implementations of pixelization. 

31 """ 

32 

33 @abc.abstractmethod 

34 def universe(self) -> RangeSet: 

35 """Return the set of all pixel indexes for this pixelization. 

36 

37 Returns 

38 ------- 

39 rangeSet : `lsst.sphgeom.RangeSet` 

40 """ 

41 pass 

42 

43 @abc.abstractmethod 

44 def pixel(self, i) -> Region: 

45 """Return the spherical region corresponding to the pixel index ``i``. 

46 

47 This region will contain all unit vectors v with ``index(v) == i``. 

48 But it may also contain points with index not equal to ``i``. 

49 To see why, consider a point that lies on the edge of a polygonal 

50 pixel - it is inside the polygons for both pixels sharing the edge, 

51 but must be assigned to exactly one pixel by the pixelization. 

52 

53 Parameters 

54 ---------- 

55 i : `int` 

56 Pixel index. 

57 

58 Returns 

59 ------- 

60 region : `lsst.sphgeom.Region` 

61 The spherical region corresponding to the pixel with index ``i`` 

62 

63 Raises 

64 ------ 

65 `InvalidArgumentException` 

66 Raised if ``i`` is not a valid pixel index. 

67 """ 

68 pass 

69 

70 @abc.abstractmethod 

71 def index(self, v: UnitVector3d) -> int: 

72 """Compute the index of the pixel. 

73 

74 Parameters 

75 ---------- 

76 v : `lsst.sphgeom.UnitVector3d` 

77 

78 Returns 

79 ------- 

80 i : `int` 

81 The index of the pixel. 

82 """ 

83 pass 

84 

85 @abc.abstractmethod 

86 def toString(self, i: int) -> str: 

87 """Convert the given pixel index to a human-readable string. 

88 

89 Parameters 

90 ---------- 

91 i : `int` 

92 

93 Returns 

94 ------- 

95 s : `str` 

96 """ 

97 pass 

98 

99 @abc.abstractmethod 

100 def envelope(self, region: Region, maxRanges: int = 0): 

101 """Return the indexes of the pixels intersecting the spherical region. 

102 

103 The ``maxRanges`` parameter can be used to limit both these costs - 

104 setting it to a non-zero value sets a cap on the number of ranges 

105 returned by this method. To meet this constraint, implementations are 

106 allowed to return pixels that do not intersect the region along with 

107 those, that do. 

108 This allows two ranges [a, b) and [c, d), a < b < c < d, to be 

109 merged into one range [a, d) (by adding in the pixels [b, c)). Since 

110 simplification proceeds by adding pixels, the return value will always 

111 be a superset of the intersecting pixels. 

112 

113 Parameters 

114 ---------- 

115 region : `lsst.sphgeom.Region` 

116 maxRanges : `int` 

117 

118 Returns 

119 ------- 

120 rangeSet : `lsst.sphgeom.RangeSet` 

121 """ 

122 pass 

123 

124 @abc.abstractmethod 

125 def interior(self, region: Region, maxRanges: int = 0): 

126 """Return the indexes of the pixels within the spherical region. 

127 

128 The ``maxRanges`` argument is analogous to the identically named 

129 envelope() argument. The only difference is that implementations must 

130 remove interior pixels to keep the number of ranges at or below the 

131 maximum. The return value is therefore always a subset of the interior 

132 pixels. 

133 

134 Parameters 

135 ---------- 

136 region : `lsst.sphgeom.Region` 

137 maxRanges : `int` 

138 

139 Returns 

140 ------- 

141 rangeSet : `lsst.sphgeom.RangeSet` 

142 """ 

143 pass