LSSTApplications: lsst.pipe.tasks.snapCombine.SnapCombineTask Class Reference

Inheritance diagram for lsst.pipe.tasks.snapCombine.SnapCombineTask:

Public Member Functions
def	__init__

def	run

def	addSnaps

def	fixMetadata

def	makeInitialPsf

Public Attributes
	schema

	algMetadata

Static Public Attributes
	ConfigClass = SnapCombineConfig

Static Private Attributes
string	_DefaultName = "snapCombine"

Detailed Description

Definition at line 96 of file snapCombine.py.

Constructor & Destructor Documentation

def lsst.pipe.tasks.snapCombine.SnapCombineTask.__init__	(	self,
		args,
		kwargs
	)

Definition at line 100 of file snapCombine.py.

 
     def __init__(self, *args, **kwargs):
         pipeBase.Task.__init__(self, *args, **kwargs)
         self.makeSubtask("repair")
         self.makeSubtask("diffim")
         self.schema = afwTable.SourceTable.makeMinimalSchema()
         self.algMetadata = dafBase.PropertyList()
         self.makeSubtask("detection", schema=self.schema)
         if self.config.doMeasurement:
             self.makeSubtask("measurement", schema=self.schema, algMetadata=self.algMetadata)

lsst::daf::base::PropertyList

Class for storing ordered metadata with comments.

Definition: PropertyList.h:81

lsst.pipe.tasks.snapCombine.SnapCombineTask.schema

schema

Definition: snapCombine.py:104

lsst.pipe.tasks.snapCombine.SnapCombineTask.__init__

def __init__

Definition: snapCombine.py:100

lsst.pipe.tasks.snapCombine.SnapCombineTask.algMetadata

algMetadata

Definition: snapCombine.py:105

Member Function Documentation

def lsst.pipe.tasks.snapCombine.SnapCombineTask.addSnaps	(	self,
		snap0,
		snap1
	)

Add two snap exposures together, returning a new exposure

@param[in] snap0 snap exposure 0
@param[in] snap1 snap exposure 1
@return combined exposure

Definition at line 178 of file snapCombine.py.

 
     def addSnaps(self, snap0, snap1):
         """Add two snap exposures together, returning a new exposure
         
         @param[in] snap0 snap exposure 0
         @param[in] snap1 snap exposure 1
         @return combined exposure
         """
         self.log.info("snapCombine addSnaps")
         
         combinedExp = snap0.Factory(snap0, True)
         combinedMi = combinedExp.getMaskedImage()
         combinedMi.set(0)
         
         weightMap = combinedMi.getImage().Factory(combinedMi.getBBox())
         weight = 1.0
         badPixelMask = afwImage.MaskU.getPlaneBitMask(self.config.badMaskPlanes)
         addToCoadd(combinedMi, weightMap, snap0.getMaskedImage(), badPixelMask, weight)
         addToCoadd(combinedMi, weightMap, snap1.getMaskedImage(), badPixelMask, weight)
 
         # pre-scaling the weight map instead of post-scaling the combinedMi saves a bit of time
         # because the weight map is a simple Image instead of a MaskedImage
         weightMap *= 0.5 # so result is sum of both images, instead of average
         combinedMi /= weightMap
         setCoaddEdgeBits(combinedMi.getMask(), weightMap)
         
         # note: none of the inputs has a valid Calib object, so that is not touched
         # Filter was already copied
         
         combinedMetadata = combinedExp.getMetadata()
         metadata0 = snap0.getMetadata()
         metadata1 = snap1.getMetadata()
         self.fixMetadata(combinedMetadata, metadata0, metadata1)
         
         return combinedExp

lsst.coadd.utils::setCoaddEdgeBits

void setCoaddEdgeBits(lsst::afw::image::Mask< lsst::afw::image::MaskPixel > &coaddMask, lsst::afw::image::Image< WeightPixelT > const &weightMap)

set edge bits of coadd mask based on weight map

Definition: setCoaddEdgeBits.cc:40

lsst.pipe.tasks.snapCombine.SnapCombineTask.addSnaps

def addSnaps

Definition: snapCombine.py:178

lsst.pipe.tasks.snapCombine.SnapCombineTask.fixMetadata

def fixMetadata

Definition: snapCombine.py:213

lsst.coadd.utils::addToCoadd

lsst::afw::geom::Box2I addToCoadd(lsst::afw::image::Image< CoaddPixelT > &coadd, lsst::afw::image::Image< WeightPixelT > &weightMap, lsst::afw::image::Image< CoaddPixelT > const &image, WeightPixelT weight)

add good pixels from an image to a coadd and associated weight map

Definition: addToCoadd.cc:126

def lsst.pipe.tasks.snapCombine.SnapCombineTask.fixMetadata	(	self,
		combinedMetadata,
		metadata0,
		metadata1
	)

Fix the metadata of the combined exposure (in place)

This implementation handles items specified by config.averageKeys and config.sumKeys,
which have data type restrictions. To handle other data types (such as sexagesimal
positions and ISO dates) you must supplement this method with your own code.

@param[in,out] combinedMetadata metadata of combined exposure;
    on input this is a deep copy of metadata0 (a PropertySet)
@param[in] metadata0 metadata of snap0 (a PropertySet)
@param[in] metadata1 metadata of snap1 (a PropertySet)

@note the inputs are presently PropertySets due to ticket #2542. However, in some sense
they are just PropertyLists that are missing some methods. In particular: comments and order
are preserved if you alter an existing value with set(key, value).

Definition at line 213 of file snapCombine.py.

 
     def fixMetadata(self, combinedMetadata, metadata0, metadata1):
         """Fix the metadata of the combined exposure (in place)
         
         This implementation handles items specified by config.averageKeys and config.sumKeys,
         which have data type restrictions. To handle other data types (such as sexagesimal
         positions and ISO dates) you must supplement this method with your own code.
         
         @param[in,out] combinedMetadata metadata of combined exposure;
             on input this is a deep copy of metadata0 (a PropertySet)
         @param[in] metadata0 metadata of snap0 (a PropertySet)
         @param[in] metadata1 metadata of snap1 (a PropertySet)
         
         @note the inputs are presently PropertySets due to ticket #2542. However, in some sense
         they are just PropertyLists that are missing some methods. In particular: comments and order
         are preserved if you alter an existing value with set(key, value).
         """
         keyDoAvgList = []
         if self.config.averageKeys:
             keyDoAvgList += [(key, 1) for key in self.config.averageKeys]
         if self.config.sumKeys:
             keyDoAvgList += [(key, 0) for key in self.config.sumKeys]
         for key, doAvg in keyDoAvgList:
             opStr = "average" if doAvg else "sum"
             try:
                 val0 = metadata0.get(key)
                 val1 = metadata1.get(key)
             except Exception:
                 self.log.warn("Could not %s metadata %r: missing from one or both exposures" % (opStr, key,))
                 continue
 
             try:
                 combinedVal = val0 + val1
                 if doAvg:
                     combinedVal /= 2.0
             except Exception:
                 self.log.warn("Could not %s metadata %r: value %r and/or %r not numeric" % \
                     (opStr, key, val0, val1))
                 continue
 
             combinedMetadata.set(key, combinedVal)

lsst.pipe.tasks.snapCombine.SnapCombineTask.fixMetadata

def fixMetadata

Definition: snapCombine.py:213

def lsst.pipe.tasks.snapCombine.SnapCombineTask.makeInitialPsf	(	self,
		exposure,
		fwhmPix = `None`
	)

Initialise the detection procedure by setting the PSF and WCS

@param exposure Exposure to process
@return PSF, WCS

Definition at line 254 of file snapCombine.py.

 
     def makeInitialPsf(self, exposure, fwhmPix=None):
         """Initialise the detection procedure by setting the PSF and WCS
 
         @param exposure Exposure to process
         @return PSF, WCS
         """
         assert exposure, "No exposure provided"
         wcs = exposure.getWcs()
         assert wcs, "No wcs in exposure"
         
         if fwhmPix is None:
             fwhmPix = self.config.initialPsf.fwhm / wcs.pixelScale().asArcseconds()
             
         size = self.config.initialPsf.size
         model = self.config.initialPsf.model
         self.log.info("installInitialPsf fwhm=%s pixels; size=%s pixels" % (fwhmPix, size))
         psfCls = getattr(measAlg, model + "Psf")
         psf = psfCls(size, size, fwhmPix/(2.0*num.sqrt(2*num.log(2.0))))
         return psf

def lsst.pipe.tasks.snapCombine.SnapCombineTask.run	(	self,
		snap0,
		snap1,
		defects = `None`
	)

Combine two snaps

@param[in] snap0: snapshot exposure 0
@param[in] snap1: snapshot exposure 1
@defects[in] defect list (for repair task)
@return a pipe_base Struct with fields:
- exposure: snap-combined exposure
- sources: detected sources, or None if detection not performed

Definition at line 111 of file snapCombine.py.

 
     def run(self, snap0, snap1, defects=None):
         """Combine two snaps
         
         @param[in] snap0: snapshot exposure 0
         @param[in] snap1: snapshot exposure 1
         @defects[in] defect list (for repair task)
         @return a pipe_base Struct with fields:
         - exposure: snap-combined exposure
         - sources: detected sources, or None if detection not performed
         """
         # initialize optional outputs
         sources = None
         
         if self.config.doRepair:
             self.log.info("snapCombine repair")
             psf = self.makeInitialPsf(snap0, fwhmPix=self.config.repairPsfFwhm)
             snap0.setPsf(psf)
             snap1.setPsf(psf)
             self.repair.run(snap0, defects=defects, keepCRs=False)
             self.repair.run(snap1, defects=defects, keepCRs=False)
             self.display('repair0', exposure=snap0)
             self.display('repair1', exposure=snap1)
 
         if self.config.doDiffIm:
             if self.config.doPsfMatch:
                 self.log.info("snapCombine psfMatch")
                 diffRet  = self.diffim.run(snap0, snap1, "subtractExposures")
                 diffExp  = diffRet.subtractedImage
 
                 # Measure centroid and width of kernel; dependent on ticket #1980
                 # Useful diagnostic for the degree of astrometric shift between snaps.
                 diffKern = diffRet.psfMatchingKernel
                 width, height = diffKern.getDimensions()
                 # TBD...
                 #psfAttr = measAlg.PsfAttributes(diffKern, width//2, height//2)
 
             else:
                 diffExp  = afwImage.ExposureF(snap0, True)
                 diffMi   = diffExp.getMaskedImage()
                 diffMi  -= snap1.getMaskedImage()
 
             psf = self.makeInitialPsf(snap0)
             diffExp.setPsf(psf)
             table = afwTable.SourceTable.make(self.schema)
             table.setMetadata(self.algMetadata)
             detRet = self.detection.makeSourceCatalog(table, diffExp)
             sources = detRet.sources
             fpSets = detRet.fpSets
             if self.config.doMeasurement:
                 self.measurement.measure(diffExp, sources)
         
             mask0 = snap0.getMaskedImage().getMask()
             mask1 = snap1.getMaskedImage().getMask()
             fpSets.positive.setMask(mask0, "DETECTED")
             fpSets.negative.setMask(mask1, "DETECTED")
         
             maskD = diffExp.getMaskedImage().getMask()
             fpSets.positive.setMask(maskD, "DETECTED")
             fpSets.negative.setMask(maskD, "DETECTED_NEGATIVE")
         
         combinedExp = self.addSnaps(snap0, snap1)
 
         return pipeBase.Struct(
             exposure = combinedExp,
             sources = sources,
         )