Inheritance diagram for lsst.pipe.tasks.repair.RepairTask:

Public Member Functions
def	__init__ (self, **kwargs)

def	run (self, exposure, defects=None, keepCRs=None)
	Repair an Exposure's defects and cosmic rays. More...

def	cosmicRay (self, exposure, keepCRs=None)

Static Public Attributes
	ConfigClass = RepairConfig

Detailed Description

Interpolate over defects in an exposure and handle cosmic rays

Description

RepairTask

This task operates on an lsst.afw.image.Exposure in place to interpolate over a set of lsst.meas.algorithms.Defect objects. It will also, optionally, find and interpolate any cosmic rays in the lsst.afw.image.Exposure.

Task initialization

See: lsst.pipe.base.task.Task.__init__

Inputs/Outputs to the run method

Repair an Exposure's defects and cosmic rays.

    @param[in, out] exposure  lsst.afw.image.Exposure to process.  Exposure must have a valid Psf.
                              Modified in place.
    @param[in]      defects   an lsst.meas.algorithms.DefectListT object.  If None, do no
                              defect correction.
    @param[in]      keepCRs   don't interpolate over the CR pixels (defer to RepairConfig if None)

    @throws AssertionError with the following strings:

    <DL>
      <DT> No exposure provided
      <DD> The object provided as exposure evaluates to False
      <DT> No PSF provided
      <DD> The Exposure has no associated Psf
    </DL>

Configuration parameters

See RepairConfig

Debug variables

The command line task interface supports a flag -d to import debug.py from your PYTHONPATH; see Debugging Tasks with lsstDebug for more about debug.py files.

The available variables in RepairTask are:

display

A dictionary containing debug point names as keys with frame number as value. Valid keys are:

repair.before: display image before any repair is done
repair.after: display image after cosmic ray and defect correction

displayCR

If True, display the exposure on display's frame 1 and overlay bounding boxes around detects CRs.

A complete example of using RepairTask

This code is in runRepair.py in the examples directory, and can be run as e.g.

examples/runRepair.py

Import the task. There are other imports. Read the source file for more info.

For this example, we manufacture a test image to run on.

First, create a pure Poisson noise image and a Psf to go with it. The mask plane and variance can be constructed at the same time.

Inject some cosmic rays and generate the Exposure. Exposures are MaskedImages (image + mask + variance) with other metadata (e.g. Psf and Wcs objects).

Defects are represented as bad columns of random lengths. A defect list must be constructed to pass on to the RepairTask.

Bug:: This is addressed in DM-963

Finally, the exposure can be repaired. Create an instance of the task and run it. The exposure is modified in place.

To investigate the Debug variables, put something like

import lsstDebug
def DebugInfo(name):
    di = lsstDebug.getInfo(name)        # N.b. lsstDebug.Info(name) would call us recursively
    if name == "lsst.pipe.tasks.repair":
        di.display = {'repair.before':2, 'repair.after':3}
        di.displayCR = True
    return di
 
lsstDebug.Info = DebugInfo

into your debug.py file and run runRepair.py with the –debug flag.

Conversion notes:
    Display code should be updated once we settle on a standard way of controlling what is displayed.

Definition at line 66 of file repair.py.

Constructor & Destructor Documentation

◆ init()

def lsst.pipe.tasks.repair.RepairTask.__init__	(		self,
		**	kwargs
	)

Definition at line 177 of file repair.py.

     def __init__(self, **kwargs):
         pipeBase.Task.__init__(self, **kwargs)
         if self.config.doInterpolate:
             self.makeSubtask("interp")
  

Member Function Documentation

◆ cosmicRay()

def lsst.pipe.tasks.repair.RepairTask.cosmicRay	(	self,
		exposure,
		keepCRs = `None`
	)

Mask cosmic rays

@param[in,out] exposure Exposure to process
@param[in]     keepCRs  Don't interpolate over the CR pixels (defer to pex_config if None)

Definition at line 219 of file repair.py.

     def cosmicRay(self, exposure, keepCRs=None):
         """Mask cosmic rays
  
         @param[in,out] exposure Exposure to process
         @param[in]     keepCRs  Don't interpolate over the CR pixels (defer to pex_config if None)
         """
         import lsstDebug
         display = lsstDebug.Info(__name__).display
         displayCR = lsstDebug.Info(__name__).displayCR
  
         assert exposure, "No exposure provided"
         psf = exposure.getPsf()
         assert psf, "No psf provided"
  
         # Blow away old mask
         try:
             mask = exposure.getMaskedImage().getMask()
             crBit = mask.getMaskPlane("CR")
             mask.clearMaskPlane(crBit)
         except Exception:
             pass
  
         exposure0 = exposure            # initial value of exposure
         binSize = self.config.cosmicray.background.binSize
         nx, ny = exposure.getWidth()/binSize, exposure.getHeight()/binSize
         # Treat constant background as a special case to avoid the extra complexity in calling
         # measAlg.SubtractBackgroundTask().
         if nx*ny <= 1:
             medianBg = afwMath.makeStatistics(exposure.getMaskedImage(), afwMath.MEDIAN).getValue()
             modelBg = None
         else:
             # make a deep copy of the exposure before subtracting its background,
             # because this routine is only allowed to modify the exposure by setting mask planes
             # and interpolating over defects, not changing the background level
             exposure = exposure.Factory(exposure, True)
             subtractBackgroundTask = measAlg.SubtractBackgroundTask(config=self.config.cosmicray.background)
             modelBg = subtractBackgroundTask.run(exposure).background
             medianBg = 0.0
  
         if keepCRs is None:
             keepCRs = self.config.cosmicray.keepCRs
         try:
             crs = measAlg.findCosmicRays(exposure.getMaskedImage(), psf, medianBg,
                                          pexConfig.makePropertySet(self.config.cosmicray), keepCRs)
             if modelBg:
                 # Add back background image
                 img = exposure.getMaskedImage()
                 img += modelBg.getImageF()
                 del img
                 # Replace original image with CR subtracted image
                 exposure0.setMaskedImage(exposure.getMaskedImage())
  
         except Exception:
             if display:
                 afwDisplay.Display().mtv(exposure0, title="Failed CR")
             raise
  
         num = 0
         if crs is not None:
             mask = exposure0.getMaskedImage().getMask()
             crBit = mask.getPlaneBitMask("CR")
             afwDet.setMaskFromFootprintList(mask, crs, crBit)
             num = len(crs)
  
             if display and displayCR:
                 disp = afwDisplay.Display()
                 disp.incrDefaultFrame()
                 disp.mtv(exposure0, title="Post-CR")
  
                 with disp.Buffering():
                     for cr in crs:
                         afwDisplay.utils.drawBBox(cr.getBBox(), borderWidth=0.55)
  
         self.log.info("Identified %s cosmic rays.", num)

◆ run()

def lsst.pipe.tasks.repair.RepairTask.run	(	self,
		exposure,
		defects = `None`,
		keepCRs = `None`
	)

Repair an Exposure's defects and cosmic rays.

    @param[in, out] exposure  lsst.afw.image.Exposure to process.  Exposure must have a valid Psf.
                              Modified in place.
    @param[in]      defects   an lsst.meas.algorithms.DefectListT object.  If None, do no
                              defect correction.
    @param[in]      keepCRs   don't interpolate over the CR pixels (defer to RepairConfig if None)

    @throws AssertionError with the following strings:

    <DL>
      <DT> No exposure provided
      <DD> The object provided as exposure evaluates to False
      <DT> No PSF provided
      <DD> The Exposure has no associated Psf
    </DL>

Definition at line 183 of file repair.py.

     def run(self, exposure, defects=None, keepCRs=None):
         """!Repair an Exposure's defects and cosmic rays
  
         @param[in, out] exposure  lsst.afw.image.Exposure to process.  Exposure must have a valid Psf.
                                   Modified in place.
         @param[in]      defects   an lsst.meas.algorithms.DefectListT object.  If None, do no
                                   defect correction.
         @param[in]      keepCRs   don't interpolate over the CR pixels (defer to RepairConfig if None)
  
         @throws AssertionError with the following strings:
  
         <DL>
           <DT> No exposure provided
           <DD> The object provided as exposure evaluates to False
           <DT> No PSF provided
           <DD> The Exposure has no associated Psf
         </DL>
         """
         assert exposure, "No exposure provided"
         psf = exposure.getPsf()
         assert psf, "No PSF provided"
  
         frame = getDebugFrame(self._display, "repair.before")
         if frame:
             afwDisplay.Display(frame).mtv(exposure)
  
         if defects is not None and self.config.doInterpolate:
             self.interp.run(exposure, defects=defects)
  
         if self.config.doCosmicRay:
             self.cosmicRay(exposure, keepCRs=keepCRs)
  
         frame = getDebugFrame(self._display, "repair.after")
         if frame:
             afwDisplay.Display(frame).mtv(exposure)
  

Member Data Documentation

◆ ConfigClass

lsst.pipe.tasks.repair.RepairTask.ConfigClass = RepairConfig

static

Definition at line 174 of file repair.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/pipe_tasks/21.0.0-172-gfb10e10a+18fedfabac/python/lsst/pipe/tasks/repair.py

Public Member Functions

Static Public Attributes