Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

# This file is part of daf_butler. 

# 

# Developed for the LSST Data Management System. 

# This product includes software developed by the LSST Project 

# (http://www.lsst.org). 

# See the COPYRIGHT file at the top-level directory of this distribution 

# for details of code ownership. 

# 

# This program is free software: you can redistribute it and/or modify 

# it under the terms of the GNU General Public License as published by 

# the Free Software Foundation, either version 3 of the License, or 

# (at your option) any later version. 

# 

# This program is distributed in the hope that it will be useful, 

# but WITHOUT ANY WARRANTY; without even the implied warranty of 

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

# GNU General Public License for more details. 

# 

# You should have received a copy of the GNU General Public License 

# along with this program. If not, see <http://www.gnu.org/licenses/>. 

 

import copy 

 

from lsst.daf.butler import Formatter 

 

__all__ = ("FitsExposureFormatter", ) 

 

 

class FitsExposureFormatter(Formatter): 

"""Interface for reading and writing Exposures to and from FITS files. 

""" 

extension = ".fits" 

 

parameters = frozenset(("bbox", "origin")) 

 

def read(self, fileDescriptor, component=None): 

"""Read data from a file. 

 

Parameters 

---------- 

fileDescriptor : `FileDescriptor` 

Identifies the file to read, type to read it into and parameters 

to be used for reading. 

component : `str`, optional 

Component to read from the file. Only used if the `StorageClass` 

for reading differed from the `StorageClass` used to write the 

file. 

 

Returns 

------- 

inMemoryDataset : `object` 

The requested data as a Python object. The type of object 

is controlled by the specific formatter. 

 

Raises 

------ 

ValueError 

Component requested but this file does not seem to be a concrete 

composite. 

KeyError 

Raised when parameters passed with fileDescriptor are not 

supported. 

""" 

from lsst.afw.image import LOCAL, readMetadata 

from lsst.geom import Box2I, Point2I 

 

67 ↛ 68line 67 didn't jump to line 68, because the condition on line 67 was never true if component == "metadata": 

data = readMetadata(fileDescriptor.location.path) 

else: 

# If we"re reading a non-image component, just read in a 

# single-pixel image for efficiency. 

kwds = {} 

if component not in (None, "image", "variance", "mask"): 

kwds["bbox"] = Box2I(minimum=Point2I(0, 0), maximum=Point2I(0, 0)) 

kwds["origin"] = LOCAL 

76 ↛ 78line 76 didn't jump to line 78, because the condition on line 76 was never true elif fileDescriptor.parameters is not None: 

# Just pass parameters into kwargs for constructor, but check that we recognize them. 

kwds.update(fileDescriptor.parameters) 

if not self.parameters.issuperset(kwds.keys()): 

raise KeyError("Unrecognized parameter key(s): {}".format(kwds.keys() - self.parameters)) 

# Read the file naively 

data = fileDescriptor.storageClass.pytype(fileDescriptor.location.path, **kwds) 

 

# TODO: most of the rest of this method has a lot in common with 

# FileFormatter; some refactoring could probably restore that 

# inheritance relationship and remove this duplication. 

 

# if read and write storage classes differ, more work is required 

readStorageClass = fileDescriptor.readStorageClass 

if readStorageClass != fileDescriptor.storageClass: 

91 ↛ 92line 91 didn't jump to line 92, because the condition on line 91 was never true if component is None: 

raise ValueError("Storage class inconsistency ({} vs {}) but no" 

" component requested".format(readStorageClass.name, 

fileDescriptor.storageClass.name)) 

 

# Concrete composite written as a single file (we hope) 

try: 

data = fileDescriptor.storageClass.assembler().getComponent(data, component) 

except AttributeError: 

# Defer the complaint 

data = None 

 

103 ↛ 104line 103 didn't jump to line 104, because the condition on line 103 was never true if data is None: 

raise ValueError("Unable to read data with URI {}".format(fileDescriptor.location.uri)) 

 

return data 

 

def write(self, inMemoryDataset, fileDescriptor): 

"""Write a Python object to a file. 

 

Parameters 

---------- 

inMemoryDataset : `object` 

The Python object to store. 

fileDescriptor : `FileDescriptor` 

Identifies the file to read, type to read it into and parameters 

to be used for reading. 

 

Returns 

------- 

path : `str` 

The `URI` where the primary file is stored. 

""" 

# Update the location with the formatter-preferred file extension 

fileDescriptor.location.updateExtension(self.extension) 

inMemoryDataset.writeFits(fileDescriptor.location.path) 

return fileDescriptor.location.pathInStore 

 

def predictPath(self, location): 

"""Return the path that would be returned by write, without actually 

writing. 

 

location : `Location` 

The location to simulate writing to. 

""" 

location = copy.deepcopy(location) 

location.updateExtension(self.extension) 

return location.pathInStore