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

# 

# LSST Data Management System 

# 

# Copyright 2016 AURA/LSST. 

# 

# This product includes software developed by the 

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

# 

# 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 LSST License Statement and 

# the GNU General Public License along with this program. If not, 

# see <https://www.lsstcorp.org/LegalNotices/>. 

# 

 

from lsst.ip.isr import biasCorrection, flatCorrection 

from lsst.meas.algorithms.detection import SourceDetectionTask 

from .isr import DecamIsrTask, DecamIsrConfig 

 

 

def _computeEdgeSize(rawExposure, calibExposure): 

"""Compute the number of edge trim pixels of the calibration product. 

 

Some Community Pipeline Calibration products are trimmed on their edges 

and are smaller than the raw data. Use the dimension difference between 

raw exposure and the calibration product to compute the edge trim pixels. 

@param[in] rawExposure: the data section of a raw exposure 

@param[in] calibExposure: calibration bias or flat exposure, 

known to be smaller than raw data 

@return an integer as the number of trimmed pixels on each edge 

""" 

nx, ny = rawExposure.getBBox().getDimensions() - calibExposure.getBBox().getDimensions() 

assert nx == ny, "Exposure is trimmed differently in X and Y" 

assert nx % 2 == 0, "Exposure is trimmed unevenly in X" 

assert nx >= 0, "Calibration image is larger than raw data" 

return nx//2 

 

 

class DecamCpIsrConfig(DecamIsrConfig): 

 

def setDefaults(self): 

self.biasDataProductName = "cpBias" 

self.flatDataProductName = "cpFlat" 

 

 

class DecamCpIsrTask(DecamIsrTask): 

"""Perform ISR task using Community Pipeline Calibration Products MasterCal 

 

The CP MasterCal products have butler dataset types cpBias and cpFlat, 

different from the LSST-generated calibration products (bias/flat). 

""" 

ConfigClass = DecamCpIsrConfig 

 

def biasCorrection(self, exposure, biasExposure): 

"""Apply bias correction in place 

 

DECam bias products have been trimmed and are smaller than 

the raw exposure. The size of edge trim is computed based 

on the dimensions of the input data. Only process the inner 

part of the raw exposure, and mask the outer pixels as EDGE. 

 

@param[in,out] exposure: exposure to process 

@param[in] biasExposure: bias exposure 

""" 

nEdge = _computeEdgeSize(exposure, biasExposure) 

if nEdge > 0: 

rawMaskedImage = exposure.getMaskedImage()[nEdge:-nEdge, 

nEdge:-nEdge] 

else: 

rawMaskedImage = exposure.getMaskedImage() 

biasCorrection(rawMaskedImage, biasExposure.getMaskedImage()) 

# Mask the unprocessed edge pixels as EDGE 

SourceDetectionTask.setEdgeBits( 

exposure.getMaskedImage(), 

rawMaskedImage.getBBox(), 

exposure.getMaskedImage().getMask().getPlaneBitMask("EDGE") 

) 

 

def flatCorrection(self, exposure, flatExposure): 

"""Apply flat correction in place 

 

DECam flat products have been trimmed and are smaller than 

the raw exposure. The size of edge trim is computed based 

on the dimensions of the input data. Only process the inner 

part of the raw exposure, and mask the outer pixels as EDGE. 

 

@param[in,out] exposure: exposure to process 

@param[in] flatExposure: flatfield exposure 

""" 

nEdge = _computeEdgeSize(exposure, flatExposure) 

if nEdge > 0: 

rawMaskedImage = exposure.getMaskedImage()[nEdge:-nEdge, 

nEdge:-nEdge] 

else: 

rawMaskedImage = exposure.getMaskedImage() 

flatCorrection( 

rawMaskedImage, 

flatExposure.getMaskedImage(), 

self.config.flatScalingType, 

self.config.flatUserScale 

) 

# Mask the unprocessed edge pixels as EDGE 

SourceDetectionTask.setEdgeBits( 

exposure.getMaskedImage(), 

rawMaskedImage.getBBox(), 

exposure.getMaskedImage().getMask().getPlaneBitMask("EDGE") 

)