lsst.pipe.tasks.repair.RepairTask Class Reference

Interpolate over defects in an exposure and handle cosmic rays. More...

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

Public Member Functions
def	run
	Repair an Exposure's defects and cosmic rays. More...
def	interpolate
def	cosmicRay

Static Public Attributes
	ConfigClass = RepairConfig

Detailed Description

Interpolate over defects in an exposure and handle cosmic rays.

Contents

• Description
• Task initialization
• Inputs/Outputs to the run method
• Configuration parameters
• Debug variables
• A complete example of using RepairTask

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.

Parameters

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

Exceptions

AssertionError

with the following strings:

No exposure provided

The object provided as exposure evaluates to False

No PSF provided

The Exposure has no associated Psf

Configuration parameters

See RepairConfig

Debug variables

The command line task interface supports a flag -d to import debug.py from your PYTHONPATH; see Using lsstDebug to control debugging output 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 ds9'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.

from lsst.pipe.tasks.repair import RepairTask

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.

    randArr = numpy.random.poisson(1000., xsize*ysize)
    randArr = numpy.array(randArr.reshape(ysize, xsize), dtype=numpy.float32) # force to ImageF
    factory = measAlg.GaussianPsfFactory()
    factory.addWing = False
    psf = factory.apply(4) # FWHM in pixels

    img = afwImage.makeImageFromArray(randArr)
    var = afwImage.ImageF(img, True) #copy constructor
    mask = afwImage.MaskU(xsize, ysize)

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

    # set some CRs
    for xi, yi in zip(xind, yind):
        xi, yi = int(xi), int(yi)
        img.set(xi, yi, 1e6)

    mi = afwImage.makeMaskedImage(img, mask, var)
    exp = afwImage.makeExposure(mi)
    exp.setPsf(psf)

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

def addDefects(exp, nBadCols=10):
    img = exp.getMaskedImage().getImage()
    (xsize, ysize) = img.getDimensions()
    defectList = measAlg.DefectListT()

    # set some bad cols and add them to a defect list
    for xi in numpy.random.randint(0, xsize, nBadCols):
        yi = numpy.random.randint(0, ysize)
        xi, yi = int(xi), int(yi)
        bbox = afwGeom.Box2I(afwGeom.PointI(xi, 0), afwGeom.ExtentI(1, yi+1))
        subIm = afwImage.ImageF(img, bbox)
        subIm.set(1e7)
        defectList.push_back(measAlg.Defect(bbox))

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

    repair = RepairTask(name="RepairTask")
    repair.run(exp, defects=defectList)

---

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 53 of file repair.py.

Member Function Documentation

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

Mask cosmic rays

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

Definition at line 208 of file repair.py.

    def cosmicRay(self, exposure, keepCRs=None):
        """Mask cosmic rays

        @param[in,out] exposure Exposure to process
        @param 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

        mi = exposure.getMaskedImage()
        bg = afwMath.makeStatistics(mi, afwMath.MEDIAN).getValue()

        if keepCRs is None:
            keepCRs = self.config.cosmicray.keepCRs
        try:
            crs = measAlg.findCosmicRays(mi, psf, bg, pexConfig.makePolicy(self.config.cosmicray), keepCRs)
        except Exception, e:
            if display:
                import lsst.afw.display.ds9 as ds9
                ds9.mtv(exposure, title="Failed CR")
            raise
            
        num = 0
        if crs is not None:
            mask = mi.getMask()
            crBit = mask.getPlaneBitMask("CR")
            afwDet.setMaskFromFootprintList(mask, crs, crBit)
            num = len(crs)

            if display and displayCR:
                import lsst.afw.display.ds9 as ds9
                import lsst.afw.display.utils as displayUtils

                ds9.incrDefaultFrame()
                ds9.mtv(exposure, title="Post-CR")
                
                with ds9.Buffering():
                    for cr in crs:
                        displayUtils.drawBBox(cr.getBBox(), borderWidth=0.55)

        self.log.info("Identified %s cosmic rays." % (num,))

def lsst.pipe.tasks.repair.RepairTask.interpolate	(		self,
			exposure,
			defects
	)

Interpolate over defects

@param[in,out] exposure Exposure to process
@param defects Defect list

Definition at line 192 of file repair.py.

    def interpolate(self, exposure, defects):
        """Interpolate over defects

        @param[in,out] exposure Exposure to process
        @param defects Defect list
        """
        assert exposure, "No exposure provided"
        assert defects is not None, "No defects provided"
        psf = exposure.getPsf()
        assert psf, "No psf provided"

        mi = exposure.getMaskedImage()
        fallbackValue = afwMath.makeStatistics(mi, afwMath.MEANCLIP).getValue()
        measAlg.interpolateOverDefects(mi, psf, defects, fallbackValue)
        self.log.info("Interpolated over %d defects." % len(defects))