LSSTApplications: lsst.meas.algorithms.detection Namespace Reference

Classes
class	BackgroundConfig
	Config for background estimation. More...

class	SourceDetectionConfig
	Configuration parameters for the SourceDetectionTask. More...

class	SourceDetectionTask
	Detect positive and negative sources on an exposure and return a new table.SourceCatalog. More...

Functions
def	addExposures
	Add a set of exposures together. More...

def	getBackground
	Estimate the background of an image (a thin layer on lsst.afw.math.makeBackground) More...

def	estimateBackground
	Estimate exposure's background using parameters in backgroundConfig. More...

Variables
tuple	__all__

Function Documentation

def lsst.meas.algorithms.detection.addExposures ( exposureList )

Add a set of exposures together.

Parameters

[in] exposureList sequence of exposures to add

Returns: an exposure of the same size as each exposure in exposureList, with the metadata from exposureList[0] and a masked image equal to the sum of all the exposure's masked images.

Exceptions

LsstException if the exposures do not all have the same dimensions (but does not check xy0)

Definition at line 531 of file detection.py.

 
 def addExposures(exposureList):
     """!Add a set of exposures together.
 
     \param[in] exposureList  sequence of exposures to add
 
     \return an exposure of the same size as each exposure in exposureList,
     with the metadata from exposureList[0] and a masked image equal to the
     sum of all the exposure's masked images.
 
     \throw LsstException if the exposures do not all have the same dimensions (but does not check xy0)
     """
     exposure0 = exposureList[0]
     image0 = exposure0.getMaskedImage()
 
     addedImage = image0.Factory(image0, True)
     addedImage.setXY0(image0.getXY0())
 
     for exposure in exposureList[1:]:
         image = exposure.getMaskedImage()
         addedImage += image
 
     addedExposure = exposure0.Factory(addedImage, exposure0.getWcs())
     return addedExposure

lsst::meas::algorithms.detection.addExposures

def addExposures

Add a set of exposures together.

Definition: detection.py:531

def lsst.meas.algorithms.detection.estimateBackground	(	exposure,
		backgroundConfig,
		subtract = `True`,
		stats = `True`,
		statsKeys = `None`
	)

Estimate exposure's background using parameters in backgroundConfig.

If subtract is true, make a copy of the exposure and subtract the background. If stats is True, measure the mean and variance of the background and add them to the background-subtracted exposure's metadata with keys "BGMEAN" and "BGVAR", or the keys given in statsKeys (2-tuple of strings).

Return background, backgroundSubtractedExposure

Definition at line 639 of file detection.py.

 
                        statsKeys=None):
     """!Estimate exposure's background using parameters in backgroundConfig.
 
     If subtract is true, make a copy of the exposure and subtract the background.
     If `stats` is True, measure the mean and variance of the background and
     add them to the background-subtracted exposure's metadata with keys
     "BGMEAN" and "BGVAR", or the keys given in `statsKeys` (2-tuple of strings).
 
     Return background, backgroundSubtractedExposure
     """
 
     displayBackground = lsstDebug.Info(__name__).displayBackground
 
     maskedImage = exposure.getMaskedImage()
 
     background = getBackground(maskedImage, backgroundConfig)
 
     if not background:
         raise RuntimeError, "Unable to estimate background for exposure"
 
     bgimg = None
 
     if displayBackground > 1:
         bgimg = background.getImageF()
         ds9.mtv(bgimg, title="background", frame=1)
 
     if not subtract:
         return background, None
 
     bbox = maskedImage.getBBox()
     backgroundSubtractedExposure = exposure.Factory(exposure, bbox, afwImage.PARENT, True)
     copyImage = backgroundSubtractedExposure.getMaskedImage().getImage()
     if bgimg is None:
         bgimg = background.getImageF()
     copyImage -= bgimg
 
     # Record statistics of the background in the bgsub exposure metadata.
     # (lsst.daf.base.PropertySet)
     if stats:
         if statsKeys is None:
             mnkey  = 'BGMEAN'
             varkey = 'BGVAR'
         else:
             mnkey, varkey = statsKeys
         meta = backgroundSubtractedExposure.getMetadata()
         s = afwMath.makeStatistics(bgimg, afwMath.MEAN | afwMath.VARIANCE)
         bgmean = s.getValue(afwMath.MEAN)
         bgvar = s.getValue(afwMath.VARIANCE)
         meta.addDouble(mnkey, bgmean)
         meta.addDouble(varkey, bgvar)
 
     if displayBackground:
         ds9.mtv(backgroundSubtractedExposure, title="subtracted")
 
     return background, backgroundSubtractedExposure
 estimateBackground.ConfigClass = BackgroundConfig

def lsst.meas.algorithms.detection.getBackground	(	image,
		backgroundConfig,
		nx = `0`,
		ny = `0`,
		algorithm = `None`
	)

Estimate the background of an image (a thin layer on lsst.afw.math.makeBackground)

Parameters

[in]	image	image whose background is to be computed
[in]	backgroundConfig	configuration (a BackgroundConfig)
[in]	nx	number of x bands; 0 for default
[in]	ny	number of y bands; 0 for default
[in]	algorithm	name of interpolation algorithm; see lsst.afw.math.BackgroundControl for details

Definition at line 555 of file detection.py.

 
 def getBackground(image, backgroundConfig, nx=0, ny=0, algorithm=None):
     """!Estimate the background of an image (a thin layer on lsst.afw.math.makeBackground)
 
     \param[in] image  image whose background is to be computed
     \param[in] backgroundConfig  configuration (a BackgroundConfig)
     \param[in] nx  number of x bands; 0 for default
     \param[in] ny  number of y bands; 0 for default
     \param[in] algorithm  name of interpolation algorithm; see lsst.afw.math.BackgroundControl for details
     """
     backgroundConfig.validate();
 
     logger = pexLogging.getDefaultLog()
     logger = pexLogging.Log(logger,"lsst.meas.algorithms.detection.getBackground")
 
     if not nx:
         nx = image.getWidth()//backgroundConfig.binSize + 1
     if not ny:
         ny = image.getHeight()//backgroundConfig.binSize + 1
 
     sctrl = afwMath.StatisticsControl()
     sctrl.setAndMask(reduce(lambda x, y: x | image.getMask().getPlaneBitMask(y),
                             backgroundConfig.ignoredPixelMask, 0x0))
     sctrl.setNanSafe(backgroundConfig.isNanSafe)
 
     pl = pexLogging.Debug("lsst.meas.algorithms.detection.getBackground")
     pl.debug(3, "Ignoring mask planes: %s" % ", ".join(backgroundConfig.ignoredPixelMask))
 
     if not algorithm:
         algorithm = backgroundConfig.algorithm
 
     bctrl = afwMath.BackgroundControl(algorithm, nx, ny,
                                       backgroundConfig.undersampleStyle, sctrl,
                                       backgroundConfig.statisticsProperty)
 
     # TODO: The following check should really be done within afw/math.  With the
     #       current code structure, it would need to be accounted for in the
     #       doGetImage() funtion in BackgroundMI.cc (which currently only checks
     #       against the interpoation settings which is not appropriate when
     #       useApprox=True) and/or the makeApproximate() function in
     #       afw/Approximate.cc.
     #       See ticket DM-2920: "Clean up code in afw for Approximate background
     #       estimation" (which includes a note to remove the following and the
     #       similar checks in pipe_tasks/matchBackgrounds.py once implemented)
     #
     # Check that config setting of approxOrder/binSize make sense
     # (i.e. ngrid (= shortDimension/binSize) > approxOrderX) and perform
     # appropriate undersampleStlye behavior.
     if backgroundConfig.useApprox:
         if not backgroundConfig.approxOrderY in (backgroundConfig.approxOrderX,-1):
             raise ValueError("Error: approxOrderY not in (approxOrderX, -1)")
         order = backgroundConfig.approxOrderX
         minNumberGridPoints = backgroundConfig.approxOrderX + 1
         if min(nx,ny) <= backgroundConfig.approxOrderX:
             logger.warn("Too few points in grid to constrain fit: min(nx, ny) < approxOrder) "+
                         "[min(%d, %d) < %d]" % (nx, ny, backgroundConfig.approxOrderX))
             if backgroundConfig.undersampleStyle == "THROW_EXCEPTION":
                 raise ValueError("Too few points in grid (%d, %d) for order (%d) and binsize (%d)" % (
                         nx, ny, backgroundConfig.approxOrderX, backgroundConfig.binSize))
             elif backgroundConfig.undersampleStyle == "REDUCE_INTERP_ORDER":
                 if order < 1:
                     raise ValueError("Cannot reduce approxOrder below 0.  " +
                                      "Try using undersampleStyle = \"INCREASE_NXNYSAMPLE\" instead?")
                 order = min(nx, ny) - 1
                 logger.warn("Reducing approxOrder to %d" % order)
             elif backgroundConfig.undersampleStyle == "INCREASE_NXNYSAMPLE":
                 newBinSize = min(image.getWidth(),image.getHeight())//(minNumberGridPoints-1)
                 if newBinSize < 1:
                     raise ValueError("Binsize must be greater than 0")
                 newNx = image.getWidth()//newBinSize + 1
                 newNy = image.getHeight()//newBinSize + 1
                 bctrl.setNxSample(newNx)
                 bctrl.setNySample(newNy)
                 logger.warn("Decreasing binSize from %d to %d for a grid of (%d, %d)" %
                             (backgroundConfig.binSize, newBinSize, newNx, newNy))
 
         actrl = afwMath.ApproximateControl(afwMath.ApproximateControl.CHEBYSHEV, order, order,
                                            backgroundConfig.weighting)
         bctrl.setApproximateControl(actrl)
 
     return afwMath.makeBackground(image, bctrl)
 
 getBackground.ConfigClass = BackgroundConfig