lsst.meas.deblender.deblend.SourceDeblendTask Class Reference

Split blended sources into individual sources. More...

Inheritance diagram for lsst.meas.deblender.deblend.SourceDeblendTask:

Public Member Functions
def	__init__ (self, schema, peakSchema=None, **kwargs)
	Create the task, adding necessary fields to the given schema. More...
def	addSchemaKeys (self, schema)
def	run (self, exposure, sources)
	Get the psf from the provided exposure and then run deblend(). More...
def	deblend (self, exposure, srcs, psf)
	Deblend. More...
def	preSingleDeblendHook (self, exposure, srcs, i, fp, psf, psf_fwhm, sigma1)
def	postSingleDeblendHook (self, exposure, srcs, i, npre, kids, fp, psf, psf_fwhm, sigma1, res)
def	isLargeFootprint (self, footprint)
def	isMasked (self, footprint, mask)
def	skipParent (self, source, mask)

Public Attributes
	schema
	toCopyFromParent
	peakSchemaMapper
	nChildKey
	psfKey
	psfCenterKey
	psfFluxKey
	tooManyPeaksKey
	tooBigKey
	maskedKey
	deblendFailedKey
	deblendSkippedKey
	deblendRampedTemplateKey
	deblendPatchedTemplateKey
	hasStrayFluxKey

Static Public Attributes
	ConfigClass = SourceDeblendConfig

Detailed Description

Split blended sources into individual sources.

This task has no return value; it only modifies the SourceCatalog in-place.

Definition at line 150 of file deblend.py.

Constructor & Destructor Documentation

__init__()

def lsst.meas.deblender.deblend.SourceDeblendTask.__init__	(		self,
			schema,
			peakSchema = None,
		**	kwargs
	)

Create the task, adding necessary fields to the given schema.

Parameters

[in,out]	schema	Schema object for measurement fields; will be modified in-place.
[in]	peakSchema	Schema of Footprint Peaks that will be passed to the deblender. Any fields beyond the PeakTable minimal schema will be transferred to the main source Schema. If None, no fields will be transferred from the Peaks.
[in]	**kwargs	Passed to Task.__init__.

Definition at line 161 of file deblend.py.

    def __init__(self, schema, peakSchema=None, **kwargs):
        """!
        Create the task, adding necessary fields to the given schema.
 
        @param[in,out] schema        Schema object for measurement fields; will be modified in-place.
        @param[in]     peakSchema    Schema of Footprint Peaks that will be passed to the deblender.
                                     Any fields beyond the PeakTable minimal schema will be transferred
                                     to the main source Schema.  If None, no fields will be transferred
                                     from the Peaks.
        @param[in]     **kwargs      Passed to Task.__init__.
        """
        pipeBase.Task.__init__(self, **kwargs)
        self.schema = schema
        self.toCopyFromParent = [item.key for item in self.schema
                                 if item.field.getName().startswith("merge_footprint")]
        peakMinimalSchema = afwDet.PeakTable.makeMinimalSchema()
        if peakSchema is None:
            # In this case, the peakSchemaMapper will transfer nothing, but we'll still have one
            # to simplify downstream code
            self.peakSchemaMapper = afwTable.SchemaMapper(peakMinimalSchema, schema)
        else:
            self.peakSchemaMapper = afwTable.SchemaMapper(peakSchema, schema)
            for item in peakSchema:
                if item.key not in peakMinimalSchema:
                    self.peakSchemaMapper.addMapping(item.key, item.field)
                    # Because SchemaMapper makes a copy of the output schema you give its ctor, it isn't
                    # updating this Schema in place.  That's probably a design flaw, but in the meantime,
                    # we'll keep that schema in sync with the peakSchemaMapper.getOutputSchema() manually,
                    # by adding the same fields to both.
                    schema.addField(item.field)
            assert schema == self.peakSchemaMapper.getOutputSchema(), "Logic bug mapping schemas"
        self.addSchemaKeys(schema)
 

Member Function Documentation

addSchemaKeys()

def lsst.meas.deblender.deblend.SourceDeblendTask.addSchemaKeys	(		self,
			schema
	)

Definition at line 194 of file deblend.py.

    def addSchemaKeys(self, schema):
        self.nChildKey = schema.addField('deblend_nChild', type=np.int32,
                                         doc='Number of children this object has (defaults to 0)')
        self.psfKey = schema.addField('deblend_deblendedAsPsf', type='Flag',
                                      doc='Deblender thought this source looked like a PSF')
        self.psfCenterKey = afwTable.Point2DKey.addFields(schema, 'deblend_psfCenter',
                                                          'If deblended-as-psf, the PSF centroid', "pixel")
        self.psfFluxKey = schema.addField('deblend_psf_instFlux', type='D',
                                          doc='If deblended-as-psf, the instrumental PSF flux', units='count')
        self.tooManyPeaksKey = schema.addField('deblend_tooManyPeaks', type='Flag',
                                               doc='Source had too many peaks; '
                                               'only the brightest were included')
        self.tooBigKey = schema.addField('deblend_parentTooBig', type='Flag',
                                         doc='Parent footprint covered too many pixels')
        self.maskedKey = schema.addField('deblend_masked', type='Flag',
                                         doc='Parent footprint was predominantly masked')
 
        if self.config.catchFailures:
            self.deblendFailedKey = schema.addField('deblend_failed', type='Flag',
                                                    doc="Deblending failed on source")
 
        self.deblendSkippedKey = schema.addField('deblend_skipped', type='Flag',
                                                 doc="Deblender skipped this source")
 
        self.deblendRampedTemplateKey = schema.addField(
            'deblend_rampedTemplate', type='Flag',
            doc=('This source was near an image edge and the deblender used '
                 '"ramp" edge-handling.'))
 
        self.deblendPatchedTemplateKey = schema.addField(
            'deblend_patchedTemplate', type='Flag',
            doc=('This source was near an image edge and the deblender used '
                 '"patched" edge-handling.'))
 
        self.hasStrayFluxKey = schema.addField(
            'deblend_hasStrayFlux', type='Flag',
            doc=('This source was assigned some stray flux'))
 
        self.log.trace('Added keys to schema: %s', ", ".join(str(x) for x in (
                       self.nChildKey, self.psfKey, self.psfCenterKey, self.psfFluxKey,
                       self.tooManyPeaksKey, self.tooBigKey)))
 

deblend()

def lsst.meas.deblender.deblend.SourceDeblendTask.deblend	(		self,
			exposure,
			srcs,
			psf
	)

Deblend.

Parameters

[in]	exposure	Exposure to process
[in,out]	srcs	SourceCatalog containing sources detected on this exposure.
[in]	psf	PSF

Returns

None

Definition at line 256 of file deblend.py.

    def deblend(self, exposure, srcs, psf):
        """!
        Deblend.
 
        @param[in]     exposure Exposure to process
        @param[in,out] srcs     SourceCatalog containing sources detected on this exposure.
        @param[in]     psf      PSF
 
        @return None
        """
        self.log.info("Deblending %d sources" % len(srcs))
 
        from lsst.meas.deblender.baseline import deblend
 
        # find the median stdev in the image...
        mi = exposure.getMaskedImage()
        statsCtrl = afwMath.StatisticsControl()
        statsCtrl.setAndMask(mi.getMask().getPlaneBitMask(self.config.maskPlanes))
        stats = afwMath.makeStatistics(mi.getVariance(), mi.getMask(), afwMath.MEDIAN, statsCtrl)
        sigma1 = math.sqrt(stats.getValue(afwMath.MEDIAN))
        self.log.trace('sigma1: %g', sigma1)
 
        n0 = len(srcs)
        nparents = 0
        for i, src in enumerate(srcs):
            # t0 = time.clock()
 
            fp = src.getFootprint()
            pks = fp.getPeaks()
 
            # Since we use the first peak for the parent object, we should propagate its flags
            # to the parent source.
            src.assign(pks[0], self.peakSchemaMapper)
 
            if len(pks) < 2:
                continue
 
            if self.isLargeFootprint(fp):
                src.set(self.tooBigKey, True)
                self.skipParent(src, mi.getMask())
                self.log.warn('Parent %i: skipping large footprint (area: %i)',
                              int(src.getId()), int(fp.getArea()))
                continue
            if self.isMasked(fp, exposure.getMaskedImage().getMask()):
                src.set(self.maskedKey, True)
                self.skipParent(src, mi.getMask())
                self.log.warn('Parent %i: skipping masked footprint (area: %i)',
                              int(src.getId()), int(fp.getArea()))
                continue
 
            nparents += 1
            bb = fp.getBBox()
            psf_fwhm = self._getPsfFwhm(psf, bb)
 
            self.log.trace('Parent %i: deblending %i peaks', int(src.getId()), len(pks))
 
            self.preSingleDeblendHook(exposure, srcs, i, fp, psf, psf_fwhm, sigma1)
            npre = len(srcs)
 
            # This should really be set in deblend, but deblend doesn't have access to the src
            src.set(self.tooManyPeaksKey, len(fp.getPeaks()) > self.config.maxNumberOfPeaks)
 
            try:
                res = deblend(
                    fp, mi, psf, psf_fwhm, sigma1=sigma1,
                    psfChisqCut1=self.config.psfChisq1,
                    psfChisqCut2=self.config.psfChisq2,
                    psfChisqCut2b=self.config.psfChisq2b,
                    maxNumberOfPeaks=self.config.maxNumberOfPeaks,
                    strayFluxToPointSources=self.config.strayFluxToPointSources,
                    assignStrayFlux=self.config.assignStrayFlux,
                    strayFluxAssignment=self.config.strayFluxRule,
                    rampFluxAtEdge=(self.config.edgeHandling == 'ramp'),
                    patchEdges=(self.config.edgeHandling == 'noclip'),
                    tinyFootprintSize=self.config.tinyFootprintSize,
                    clipStrayFluxFraction=self.config.clipStrayFluxFraction,
                    weightTemplates=self.config.weightTemplates,
                    removeDegenerateTemplates=self.config.removeDegenerateTemplates,
                    maxTempDotProd=self.config.maxTempDotProd,
                    medianSmoothTemplate=self.config.medianSmoothTemplate
                )
                if self.config.catchFailures:
                    src.set(self.deblendFailedKey, False)
            except Exception as e:
                if self.config.catchFailures:
                    self.log.warn("Unable to deblend source %d: %s" % (src.getId(), e))
                    src.set(self.deblendFailedKey, True)
                    import traceback
                    traceback.print_exc()
                    continue
                else:
                    raise
 
            kids = []
            nchild = 0
            for j, peak in enumerate(res.deblendedParents[0].peaks):
                heavy = peak.getFluxPortion()
                if heavy is None or peak.skip:
                    src.set(self.deblendSkippedKey, True)
                    if not self.config.propagateAllPeaks:
                        # Don't care
                        continue
                    # We need to preserve the peak: make sure we have enough info to create a minimal
                    # child src
                    self.log.trace("Peak at (%i,%i) failed.  Using minimal default info for child.",
                                   pks[j].getIx(), pks[j].getIy())
                    if heavy is None:
                        # copy the full footprint and strip out extra peaks
                        foot = afwDet.Footprint(src.getFootprint())
                        peakList = foot.getPeaks()
                        peakList.clear()
                        peakList.append(peak.peak)
                        zeroMimg = afwImage.MaskedImageF(foot.getBBox())
                        heavy = afwDet.makeHeavyFootprint(foot, zeroMimg)
                    if peak.deblendedAsPsf:
                        if peak.psfFitFlux is None:
                            peak.psfFitFlux = 0.0
                        if peak.psfFitCenter is None:
                            peak.psfFitCenter = (peak.peak.getIx(), peak.peak.getIy())
 
                assert(len(heavy.getPeaks()) == 1)
 
                src.set(self.deblendSkippedKey, False)
                child = srcs.addNew()
                nchild += 1
                for key in self.toCopyFromParent:
                    child.set(key, src.get(key))
                child.assign(heavy.getPeaks()[0], self.peakSchemaMapper)
                child.setParent(src.getId())
                child.setFootprint(heavy)
                child.set(self.psfKey, peak.deblendedAsPsf)
                child.set(self.hasStrayFluxKey, peak.strayFlux is not None)
                if peak.deblendedAsPsf:
                    (cx, cy) = peak.psfFitCenter
                    child.set(self.psfCenterKey, geom.Point2D(cx, cy))
                    child.set(self.psfFluxKey, peak.psfFitFlux)
                child.set(self.deblendRampedTemplateKey, peak.hasRampedTemplate)
                child.set(self.deblendPatchedTemplateKey, peak.patched)
                kids.append(child)
 
            # Child footprints may extend beyond the full extent of their parent's which
            # results in a failure of the replace-by-noise code to reinstate these pixels
            # to their original values.  The following updates the parent footprint
            # in-place to ensure it contains the full union of itself and all of its
            # children's footprints.
            spans = src.getFootprint().spans
            for child in kids:
                spans = spans.union(child.getFootprint().spans)
            src.getFootprint().setSpans(spans)
 
            src.set(self.nChildKey, nchild)
 
            self.postSingleDeblendHook(exposure, srcs, i, npre, kids, fp, psf, psf_fwhm, sigma1, res)
            # print('Deblending parent id', src.getId(), 'took', time.clock() - t0)
 
        n1 = len(srcs)
        self.log.info('Deblended: of %i sources, %i were deblended, creating %i children, total %i sources'
                      % (n0, nparents, n1-n0, n1))
 

isLargeFootprint()

def lsst.meas.deblender.deblend.SourceDeblendTask.isLargeFootprint	(		self,
			footprint
	)

Returns whether a Footprint is large

'Large' is defined by thresholds on the area, size and axis ratio.
These may be disabled independently by configuring them to be non-positive.

This is principally intended to get rid of satellite streaks, which the
deblender or other downstream processing can have trouble dealing with
(e.g., multiple large HeavyFootprints can chew up memory).

Definition at line 421 of file deblend.py.

    def isLargeFootprint(self, footprint):
        """Returns whether a Footprint is large
 
        'Large' is defined by thresholds on the area, size and axis ratio.
        These may be disabled independently by configuring them to be non-positive.
 
        This is principally intended to get rid of satellite streaks, which the
        deblender or other downstream processing can have trouble dealing with
        (e.g., multiple large HeavyFootprints can chew up memory).
        """
        if self.config.maxFootprintArea > 0 and footprint.getArea() > self.config.maxFootprintArea:
            return True
        if self.config.maxFootprintSize > 0:
            bbox = footprint.getBBox()
            if max(bbox.getWidth(), bbox.getHeight()) > self.config.maxFootprintSize:
                return True
        if self.config.minFootprintAxisRatio > 0:
            axes = afwEll.Axes(footprint.getShape())
            if axes.getB() < self.config.minFootprintAxisRatio*axes.getA():
                return True
        return False
 

isMasked()

def lsst.meas.deblender.deblend.SourceDeblendTask.isMasked	(		self,
			footprint,
			mask
	)

Returns whether the footprint violates the mask limits

Definition at line 443 of file deblend.py.

    def isMasked(self, footprint, mask):
        """Returns whether the footprint violates the mask limits"""
        size = float(footprint.getArea())
        for maskName, limit in self.config.maskLimits.items():
            maskVal = mask.getPlaneBitMask(maskName)
            unmaskedSpan = footprint.spans.intersectNot(mask, maskVal)  # spanset of unmasked pixels
            if (size - unmaskedSpan.getArea())/size > limit:
                return True
        return False
 

postSingleDeblendHook()

def lsst.meas.deblender.deblend.SourceDeblendTask.postSingleDeblendHook	(		self,
			exposure,
			srcs,
			i,
			npre,
			kids,
			fp,
			psf,
			psf_fwhm,
			sigma1,
			res
	)

Definition at line 418 of file deblend.py.

    def postSingleDeblendHook(self, exposure, srcs, i, npre, kids, fp, psf, psf_fwhm, sigma1, res):
        pass
 

preSingleDeblendHook()

def lsst.meas.deblender.deblend.SourceDeblendTask.preSingleDeblendHook	(		self,
			exposure,
			srcs,
			i,
			fp,
			psf,
			psf_fwhm,
			sigma1
	)

Definition at line 415 of file deblend.py.

    def preSingleDeblendHook(self, exposure, srcs, i, fp, psf, psf_fwhm, sigma1):
        pass
 

run()

def lsst.meas.deblender.deblend.SourceDeblendTask.run	(		self,
			exposure,
			sources
	)

Get the psf from the provided exposure and then run deblend().

Parameters

[in]	exposure	Exposure to process
[in,out]	sources	SourceCatalog containing sources detected on this exposure.

Returns

None

Definition at line 237 of file deblend.py.

    def run(self, exposure, sources):
        """!
        Get the psf from the provided exposure and then run deblend().
 
        @param[in]     exposure Exposure to process
        @param[in,out] sources  SourceCatalog containing sources detected on this exposure.
 
        @return None
        """
        psf = exposure.getPsf()
        assert sources.getSchema() == self.schema
        self.deblend(exposure, sources, psf)
 

skipParent()

def lsst.meas.deblender.deblend.SourceDeblendTask.skipParent	(		self,
			source,
			mask
	)

Indicate that the parent source is not being deblended

We set the appropriate flags and mask.

@param source  The source to flag as skipped
@param mask  The mask to update

Definition at line 453 of file deblend.py.

    def skipParent(self, source, mask):
        """Indicate that the parent source is not being deblended
 
        We set the appropriate flags and mask.
 
        @param source  The source to flag as skipped
        @param mask  The mask to update
        """
        fp = source.getFootprint()
        source.set(self.deblendSkippedKey, True)
        source.set(self.nChildKey, len(fp.getPeaks()))  # It would have this many if we deblended them all
        if self.config.notDeblendedMask:
            mask.addMaskPlane(self.config.notDeblendedMask)
            fp.spans.setMask(mask, mask.getPlaneBitMask(self.config.notDeblendedMask))

Member Data Documentation

ConfigClass

lsst.meas.deblender.deblend.SourceDeblendTask.ConfigClass = SourceDeblendConfig

static

Definition at line 158 of file deblend.py.

deblendFailedKey

lsst.meas.deblender.deblend.SourceDeblendTask.deblendFailedKey

Definition at line 212 of file deblend.py.

deblendPatchedTemplateKey

lsst.meas.deblender.deblend.SourceDeblendTask.deblendPatchedTemplateKey

Definition at line 223 of file deblend.py.

deblendRampedTemplateKey

lsst.meas.deblender.deblend.SourceDeblendTask.deblendRampedTemplateKey

Definition at line 218 of file deblend.py.

deblendSkippedKey

lsst.meas.deblender.deblend.SourceDeblendTask.deblendSkippedKey

Definition at line 215 of file deblend.py.

hasStrayFluxKey

lsst.meas.deblender.deblend.SourceDeblendTask.hasStrayFluxKey

Definition at line 228 of file deblend.py.

maskedKey

lsst.meas.deblender.deblend.SourceDeblendTask.maskedKey

Definition at line 208 of file deblend.py.

nChildKey

lsst.meas.deblender.deblend.SourceDeblendTask.nChildKey

Definition at line 195 of file deblend.py.

peakSchemaMapper

lsst.meas.deblender.deblend.SourceDeblendTask.peakSchemaMapper

Definition at line 180 of file deblend.py.

psfCenterKey

lsst.meas.deblender.deblend.SourceDeblendTask.psfCenterKey

Definition at line 199 of file deblend.py.

psfFluxKey

lsst.meas.deblender.deblend.SourceDeblendTask.psfFluxKey

Definition at line 201 of file deblend.py.

psfKey

lsst.meas.deblender.deblend.SourceDeblendTask.psfKey

Definition at line 197 of file deblend.py.

schema

lsst.meas.deblender.deblend.SourceDeblendTask.schema

Definition at line 173 of file deblend.py.

toCopyFromParent

lsst.meas.deblender.deblend.SourceDeblendTask.toCopyFromParent

Definition at line 174 of file deblend.py.

tooBigKey

lsst.meas.deblender.deblend.SourceDeblendTask.tooBigKey

Definition at line 206 of file deblend.py.

tooManyPeaksKey

lsst.meas.deblender.deblend.SourceDeblendTask.tooManyPeaksKey

Definition at line 203 of file deblend.py.

---

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

• /j/snowflake/release/lsstsw/stack/1a1d771/Linux64/meas_deblender/20.0.0+28/python/lsst/meas/deblender/deblend.py