lsst.meas.deblender.baseline.DeblenderResult Class Reference

Public Member Functions
def	__init__ (self, footprint, mMaskedImage, psfs, psffwhms, log, maxNumberOfPeaks=0, avgNoise=None)
def	getParentProperty (self, propertyName)
def	setTemplateSums (self, templateSums, fidx=None)

Public Attributes
	filters
	log
	mMaskedImage
	footprint
	psfs
	peakCount
	deblendedParents
	peaks
	blend
	failed

Detailed Description

Collection of objects in multiple bands for a single parent footprint.

Parameters
----------
footprint: `afw.detection.Footprint`
    Parent footprint to deblend. While `maskedImages`, `psfs`,
    and `psffwhms` are lists of objects, one for each band,
    `footprint` is a single parent footprint (from a `mergedDet`)
    this is used for all bands.
mMaskedImage: `MaskedImage`\ s or `MultibandMaskedImage`
    Masked image containing the ``footprint`` in each band.
psfs: list of `afw.detection.Psf`s
    Psf of the ``maskedImage`` for each band.
psffwhm: list of `float`s
    FWHM of the ``maskedImage``'s ``psf`` in each band.
maxNumberOfPeaks: `int`, optional
    If positive, the maximum number of peaks to deblend.
    If the total number of peaks is greater than ``maxNumberOfPeaks``,
    then only the first ``maxNumberOfPeaks`` sources are deblended.
    The default is 0, which deblends all of the peaks.
avgNoise: `float`or list of `float`s, optional
    Average noise level in each ``maskedImage``.
    The default is ``None``, which estimates the noise from the median value of the
    variance plane of ``maskedImage`` for each filter.

Definition at line 47 of file baseline.py.

Constructor & Destructor Documentation

__init__()

def lsst.meas.deblender.baseline.DeblenderResult.__init__	(		self,
			footprint,
			mMaskedImage,
			psfs,
			psffwhms,
			log,
			maxNumberOfPeaks = 0,
			avgNoise = None
	)

Definition at line 74 of file baseline.py.

                 maxNumberOfPeaks=0, avgNoise=None):
        # Check if this is collection of footprints in multiple bands or a single footprint
        if not isinstance(mMaskedImage, afwImage.MultibandMaskedImage):
            mMaskedImage = [mMaskedImage]
            self.filters = [0]
        else:
            self.filters = mMaskedImage.filters
        try:
            len(psfs)
        except TypeError:
            psfs = [psfs]
        try:
            len(psffwhms)
        except TypeError:
            psffwhms = [psffwhms]
        try:
            len(avgNoise)
        except TypeError:
            if avgNoise is None:
                avgNoise = [None]*len(psfs)
            else:
                avgNoise = [avgNoise]
        # Now check that all of the parameters have the same number of entries
        if any([len(self.filters) != len(p) for p in [psfs, psffwhms, avgNoise]]):
            raise ValueError("To use the multi-color deblender, "
                             "'maskedImage', 'psf', 'psffwhm', 'avgNoise'"
                             "must have the same length, but instead have lengths: "
                             "{0}".format([len(p) for p in [mMaskedImage,
                                                            psfs,
                                                            psffwhms,
                                                            avgNoise]]))
 
        self.log = log
        self.mMaskedImage = mMaskedImage
        self.footprint = footprint
        self.psfs = psfs
 
        self.peakCount = len(footprint.getPeaks())
        if maxNumberOfPeaks > 0 and maxNumberOfPeaks < self.peakCount:
            self.peakCount = maxNumberOfPeaks
 
        # Create a DeblendedParent for the Footprint in every filter
        self.deblendedParents = OrderedDict([])
        for n, f in enumerate(self.filters):
            f = self.filters[n]
            dp = DeblendedParent(f, footprint, mMaskedImage[f], psfs[n],
                                 psffwhms[n], avgNoise[n], maxNumberOfPeaks, self)
            self.deblendedParents[self.filters[n]] = dp
 
        # Group the peaks in each color
        self.peaks = []
        for idx in range(self.peakCount):
            peakDict = OrderedDict([(f, dp.peaks[idx]) for f, dp in self.deblendedParents.items()])
            multiPeak = MultiColorPeak(peakDict, idx, self)
            self.peaks.append(multiPeak)
 
        # Result from multiband debender (if used)
        self.blend = None
        self.failed = False
 

Member Function Documentation

getParentProperty()

def lsst.meas.deblender.baseline.DeblenderResult.getParentProperty	(		self,
			propertyName
	)

Get the footprint in each filter

Definition at line 135 of file baseline.py.

    def getParentProperty(self, propertyName):
        """Get the footprint in each filter
        """
        return [getattr(dp, propertyName) for dp in self.deblendedParents]
 

setTemplateSums()

def lsst.meas.deblender.baseline.DeblenderResult.setTemplateSums	(		self,
			templateSums,
			fidx = None
	)

Definition at line 140 of file baseline.py.

    def setTemplateSums(self, templateSums, fidx=None):
        if fidx is not None:
            self.templateSums[fidx] = templateSums
        else:
            for f, templateSum in templateSums.items():
                self.deblendedParents[f].templateSum = templateSum
 
 

Member Data Documentation

blend

lsst.meas.deblender.baseline.DeblenderResult.blend

Definition at line 132 of file baseline.py.

deblendedParents

lsst.meas.deblender.baseline.DeblenderResult.deblendedParents

Definition at line 117 of file baseline.py.

failed

lsst.meas.deblender.baseline.DeblenderResult.failed

Definition at line 133 of file baseline.py.

filters

lsst.meas.deblender.baseline.DeblenderResult.filters

Definition at line 79 of file baseline.py.

footprint

lsst.meas.deblender.baseline.DeblenderResult.footprint

Definition at line 109 of file baseline.py.

log

lsst.meas.deblender.baseline.DeblenderResult.log

Definition at line 107 of file baseline.py.

mMaskedImage

lsst.meas.deblender.baseline.DeblenderResult.mMaskedImage

Definition at line 108 of file baseline.py.

peakCount

lsst.meas.deblender.baseline.DeblenderResult.peakCount

Definition at line 112 of file baseline.py.

peaks

lsst.meas.deblender.baseline.DeblenderResult.peaks

Definition at line 125 of file baseline.py.

psfs

lsst.meas.deblender.baseline.DeblenderResult.psfs

Definition at line 110 of file baseline.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_deblender/22.0.1-5-g58711c4+611d128589/python/lsst/meas/deblender/baseline.py