lsst.meas.deblender.plugins Namespace Reference

Classes
class	DeblenderPlugin

Functions
def	clipFootprintToNonzeroImpl (foot, image)
def	buildMultibandTemplates (debResult, log, useWeights=False, usePsf=False, sources=None, constraints=None, config=None, maxIter=100, bgScale=0.5, relativeError=1e-2, badMask=None)
def	fitPsfs (debResult, log, psfChisqCut1=1.5, psfChisqCut2=1.5, psfChisqCut2b=1.5, tinyFootprintSize=2)
def	buildSymmetricTemplates (debResult, log, patchEdges=False, setOrigTemplate=True)
def	rampFluxAtEdge (debResult, log, patchEdges=False)
def	medianSmoothTemplates (debResult, log, medianFilterHalfsize=2)
def	makeTemplatesMonotonic (debResult, log)
def	clipFootprintsToNonzero (debResult, log)
def	weightTemplates (debResult, log)
def	reconstructTemplates (debResult, log, maxTempDotProd=0.5)
def	apportionFlux (debResult, log, assignStrayFlux=True, strayFluxAssignment='r-to-peak', strayFluxToPointSources='necessary', clipStrayFluxFraction=0.001, getTemplateSum=False)

Function Documentation

apportionFlux()

def lsst.meas.deblender.plugins.apportionFlux	(		debResult,
			log,
			assignStrayFlux = True,
			strayFluxAssignment = 'r-to-peak',
			strayFluxToPointSources = 'necessary',
			clipStrayFluxFraction = 0.001,
			getTemplateSum = False
	)

Apportion flux to all of the peak templates in each filter

Divide the ``maskedImage`` flux amongst all of the templates based on the fraction of
flux assigned to each ``template``.
Leftover "stray flux" is assigned to peaks based on the other parameters.

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.
assignStrayFlux: `bool`, optional
    If True then flux in the parent footprint that is not covered by any of the
    template footprints is assigned to templates based on their 1/(1+r^2) distance.
    How the flux is apportioned is determined by ``strayFluxAssignment``.
strayFluxAssignment: `string`, optional
    Determines how stray flux is apportioned.
    * ``trim``: Trim stray flux and do not include in any footprints
    * ``r-to-peak`` (default): Stray flux is assigned based on (1/(1+r^2) from the peaks
    * ``r-to-footprint``: Stray flux is distributed to the footprints based on 1/(1+r^2) of the
      minimum distance from the stray flux to footprint
    * ``nearest-footprint``: Stray flux is assigned to the footprint with lowest L-1 (Manhattan)
      distance to the stray flux
strayFluxToPointSources: `string`, optional
    Determines how stray flux is apportioned to point sources
    * ``never``: never apportion stray flux to point sources
    * ``necessary`` (default): point sources are included only if there are no extended sources nearby
    * ``always``: point sources are always included in the 1/(1+r^2) splitting
clipStrayFluxFraction: `float`, optional
    Minimum stray-flux portion.
    Any stray-flux portion less than ``clipStrayFluxFraction`` is clipped to zero.
getTemplateSum: `bool`, optional
    As part of the flux calculation, the sum of the templates is calculated.
    If ``getTemplateSum==True`` then the sum of the templates is stored in the result
    (a `DeblendedFootprint`).

Returns
-------
modified: `bool`
    Apportion flux always modifies the templates, so ``modified`` is always ``True``.
    However, this should likely be the final step and it is unlikely that
    any deblender plugins will be re-run.

Definition at line 1398 of file plugins.py.

                  getTemplateSum=False):
    """Apportion flux to all of the peak templates in each filter

    Divide the ``maskedImage`` flux amongst all of the templates based on the fraction of
    flux assigned to each ``template``.
    Leftover "stray flux" is assigned to peaks based on the other parameters.

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.
    assignStrayFlux: `bool`, optional
        If True then flux in the parent footprint that is not covered by any of the
        template footprints is assigned to templates based on their 1/(1+r^2) distance.
        How the flux is apportioned is determined by ``strayFluxAssignment``.
    strayFluxAssignment: `string`, optional
        Determines how stray flux is apportioned.
        * ``trim``: Trim stray flux and do not include in any footprints
        * ``r-to-peak`` (default): Stray flux is assigned based on (1/(1+r^2) from the peaks
        * ``r-to-footprint``: Stray flux is distributed to the footprints based on 1/(1+r^2) of the
          minimum distance from the stray flux to footprint
        * ``nearest-footprint``: Stray flux is assigned to the footprint with lowest L-1 (Manhattan)
          distance to the stray flux
    strayFluxToPointSources: `string`, optional
        Determines how stray flux is apportioned to point sources
        * ``never``: never apportion stray flux to point sources
        * ``necessary`` (default): point sources are included only if there are no extended sources nearby
        * ``always``: point sources are always included in the 1/(1+r^2) splitting
    clipStrayFluxFraction: `float`, optional
        Minimum stray-flux portion.
        Any stray-flux portion less than ``clipStrayFluxFraction`` is clipped to zero.
    getTemplateSum: `bool`, optional
        As part of the flux calculation, the sum of the templates is calculated.
        If ``getTemplateSum==True`` then the sum of the templates is stored in the result
        (a `DeblendedFootprint`).

    Returns
    -------
    modified: `bool`
        Apportion flux always modifies the templates, so ``modified`` is always ``True``.
        However, this should likely be the final step and it is unlikely that
        any deblender plugins will be re-run.
    """
    validStrayPtSrc = ['never', 'necessary', 'always']
    validStrayAssign = ['r-to-peak', 'r-to-footprint', 'nearest-footprint', 'trim']
    if strayFluxToPointSources not in validStrayPtSrc:
        raise ValueError((('strayFluxToPointSources: value \"%s\" not in the set of allowed values: ') %
                          strayFluxToPointSources) + str(validStrayPtSrc))
    if strayFluxAssignment not in validStrayAssign:
        raise ValueError((('strayFluxAssignment: value \"%s\" not in the set of allowed values: ') %
                          strayFluxAssignment) + str(validStrayAssign))

    for fidx in debResult.filters:
        dp = debResult.deblendedParents[fidx]
        # Prepare inputs to "apportionFlux" call.
        # template maskedImages
        tmimgs = []
        # template footprints
        tfoots = []
        # deblended as psf
        dpsf = []
        # peak x,y
        pkx = []
        pky = []
        # indices of valid templates
        ibi = []
        bb = dp.fp.getBBox()

        for peaki, pkres in enumerate(dp.peaks):
            if pkres.skip:
                continue
            tmimgs.append(pkres.templateImage)
            tfoots.append(pkres.templateFootprint)
            # for stray flux...
            dpsf.append(pkres.deblendedAsPsf)
            pk = pkres.peak
            pkx.append(pk.getIx())
            pky.append(pk.getIy())
            ibi.append(pkres.pki)

        # Now apportion flux according to the templates
        log.trace('Apportioning flux among %i templates', len(tmimgs))
        sumimg = afwImage.ImageF(bb)
        # .getDimensions())
        # sumimg.setXY0(bb.getMinX(), bb.getMinY())

        strayopts = 0
        if strayFluxAssignment == 'trim':
            assignStrayFlux = False
            strayopts |= bUtils.STRAYFLUX_TRIM
        if assignStrayFlux:
            strayopts |= bUtils.ASSIGN_STRAYFLUX
            if strayFluxToPointSources == 'necessary':
                strayopts |= bUtils.STRAYFLUX_TO_POINT_SOURCES_WHEN_NECESSARY
            elif strayFluxToPointSources == 'always':
                strayopts |= bUtils.STRAYFLUX_TO_POINT_SOURCES_ALWAYS

            if strayFluxAssignment == 'r-to-peak':
                # this is the default
                pass
            elif strayFluxAssignment == 'r-to-footprint':
                strayopts |= bUtils.STRAYFLUX_R_TO_FOOTPRINT
            elif strayFluxAssignment == 'nearest-footprint':
                strayopts |= bUtils.STRAYFLUX_NEAREST_FOOTPRINT

        portions, strayflux = bUtils.apportionFlux(dp.maskedImage, dp.fp, tmimgs, tfoots, sumimg, dpsf,
                                                   pkx, pky, strayopts, clipStrayFluxFraction)

        # Shrink parent to union of children
        if strayFluxAssignment == 'trim':
            finalSpanSet = afwGeom.SpanSet()
            for foot in tfoots:
                finalSpanSet = finalSpanSet.union(foot.spans)
            dp.fp.setSpans(finalSpanSet)

        # Store the template sum in the deblender result
        if getTemplateSum:
            debResult.setTemplateSums(sumimg, fidx)

        # Save the apportioned fluxes
        ii = 0
        for j, (pk, pkres) in enumerate(zip(dp.fp.getPeaks(), dp.peaks)):
            if pkres.skip:
                continue
            pkres.setFluxPortion(portions[ii])

            if assignStrayFlux:
                # NOTE that due to a swig bug (https://github.com/swig/swig/issues/59)
                # we CANNOT iterate over "strayflux", but must index into it.
                stray = strayflux[ii]
            else:
                stray = None
            ii += 1

            pkres.setStrayFlux(stray)

        # Set child footprints to contain the right number of peaks.
        for j, (pk, pkres) in enumerate(zip(dp.fp.getPeaks(), dp.peaks)):
            if pkres.skip:
                continue

            for foot, add in [(pkres.templateFootprint, True), (pkres.origFootprint, True),
                              (pkres.strayFlux, False)]:
                if foot is None:
                    continue
                pks = foot.getPeaks()
                pks.clear()
                if add:
                    pks.append(pk)
    return True

buildMultibandTemplates()

def lsst.meas.deblender.plugins.buildMultibandTemplates	(		debResult,
			log,
			useWeights = False,
			usePsf = False,
			sources = None,
			constraints = None,
			config = None,
			maxIter = 100,
			bgScale = 0.5,
			relativeError = 1e-2,
			badMask = None
	)

Run the Multiband Deblender to build templates

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.
useWeights: bool, default=False
    Whether or not to use the variance map in each filter for the fit.
usePsf: bool, default=False
    Whether or not to convolve the image with the PSF in each band.
    This is not yet implemented in an optimized algorithm, so it is recommended
    to leave this term off for now
sources: list of `scarlet.source.Source` objects, default=None
    List of sources to use in the blend. By default the
    `scarlet.source.ExtendedSource` class is used, which initializes each
    source as symmetric and monotonic about a peak in the footprint peak catalog.
constraints: `scarlet.constraint.Constraint`, default=None
    Constraint to be applied to each source. If sources require different constraints,
    a list of `sources` must be created instead, which ignores the `constraints` parameter.
    When `constraints` is `None` the default constraints are used.
config: `scarlet.config.Config`, default=None
    Configuration for the blend.
    If `config` is `None` then the default `Config` is used.
maxIter: int, default=100
    Maximum iterations for a single blend.
bgScale: float
    Amount to scale the background RMS to set the floor for deblender model sizes
relativeError: float, default=1e-2
    Relative error to reach for convergence
badMask: list of str, default=`None`
    List of mask plane names to mark bad pixels.
    If `badPixelKeys` is `None`, the default keywords used are
    `["BAD", "CR", "NO_DATA", "SAT", "SUSPECT"]`.

Returns
-------
modified: `bool`
    If any templates have been created then ``modified`` is ``True``,
    otherwise it is ``False`` (meaning all of the peaks were skipped).

Definition at line 157 of file plugins.py.

                            relativeError=1e-2, badMask=None):
    """Run the Multiband Deblender to build templates

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.
    useWeights: bool, default=False
        Whether or not to use the variance map in each filter for the fit.
    usePsf: bool, default=False
        Whether or not to convolve the image with the PSF in each band.
        This is not yet implemented in an optimized algorithm, so it is recommended
        to leave this term off for now
    sources: list of `scarlet.source.Source` objects, default=None
        List of sources to use in the blend. By default the
        `scarlet.source.ExtendedSource` class is used, which initializes each
        source as symmetric and monotonic about a peak in the footprint peak catalog.
    constraints: `scarlet.constraint.Constraint`, default=None
        Constraint to be applied to each source. If sources require different constraints,
        a list of `sources` must be created instead, which ignores the `constraints` parameter.
        When `constraints` is `None` the default constraints are used.
    config: `scarlet.config.Config`, default=None
        Configuration for the blend.
        If `config` is `None` then the default `Config` is used.
    maxIter: int, default=100
        Maximum iterations for a single blend.
    bgScale: float
        Amount to scale the background RMS to set the floor for deblender model sizes
    relativeError: float, default=1e-2
        Relative error to reach for convergence
    badMask: list of str, default=`None`
        List of mask plane names to mark bad pixels.
        If `badPixelKeys` is `None`, the default keywords used are
        `["BAD", "CR", "NO_DATA", "SAT", "SUSPECT"]`.

    Returns
    -------
    modified: `bool`
        If any templates have been created then ``modified`` is ``True``,
        otherwise it is ``False`` (meaning all of the peaks were skipped).
    """
    # Extract coordinates from each MultiColorPeak
    bbox = debResult.footprint.getBBox()
    peakSchema = debResult.footprint.peaks.getSchema()
    xmin = bbox.getMinX()
    ymin = bbox.getMinY()
    peaks = [[pk.y-ymin, pk.x-xmin] for pk in debResult.peaks]
    xy0 = bbox.getMin()

    # Create the data array from the masked images
    mMaskedImage = debResult.mMaskedImage[:, debResult.footprint.getBBox()]
    data = mMaskedImage.image.array

    # Use the inverse variance as the weights
    if useWeights:
        weights = 1/mMaskedImage.variance.array
    else:
        weights = np.ones_like(data)

    # Use the mask plane to mask bad pixels and
    # the footprint to mask out pixels outside the footprint
    if badMask is None:
        badMask = ["BAD", "CR", "NO_DATA", "SAT", "SUSPECT"]
    fpMask = afwImage.Mask(bbox)
    debResult.footprint.spans.setMask(fpMask, 1)
    fpMask = ~fpMask.getArray().astype(bool)
    badPixels = mMaskedImage.mask.getPlaneBitMask(badMask)
    mask = (mMaskedImage.mask.array & badPixels) | fpMask[None, :]
    weights[mask > 0] = 0

    # Extract the PSF from each band for PSF convolution
    if usePsf:
        psfs = []
        for psf in debResult.psfs:
            psfs.append(psf.computeKernelImage().array)
        psf = np.array(psfs)
    else:
        psf = None

    bg_rms = np.array([debResult.deblendedParents[f].avgNoise for f in debResult.filters])*bgScale
    if sources is None:
        # If only a single constraint was given, use it for all of the sources
        if constraints is None or isinstance(constraints[0], scarlet.constraints.Constraint):
            constraints = [constraints] * len(peaks)
        sources = [
            scarlet.source.ExtendedSource(center=peak,
                                          img=data,
                                          bg_rms=bg_rms,
                                          constraints=constraints[pk],
                                          psf=psf,
                                          symmetric=True,
                                          monotonic=True,
                                          thresh=1.0,
                                          config=config)
            for pk, peak in enumerate(peaks)
        ]

    # When a footprint includes only non-detections
    # (peaks in the noise too low to deblend as a source)
    # the deblender currently fails.
    try:
        blend = scarlet.blend.Blend(components=sources)
        blend.set_data(img=data, weights=weights, bg_rms=bg_rms, config=config)
        blend.fit(maxIter, e_rel=relativeError)
    except scarlet.source.SourceInitError as e:
        log.warn(e.args[0])
        debResult.failed = True
        return False
    except np.linalg.LinAlgError:
        log.warn("Deblend failed catastrophically, most likely due to no signal in the footprint")
        debResult.failed = True
        return False
    debResult.blend = blend

    modified = False
    # Create the Templates for each peak in each filter
    for pk, source in enumerate(blend.sources):
        src = source.components[0]
        _cx = src.Nx >> 1
        _cy = src.Ny >> 1

        if debResult.peaks[pk].skip:
            continue
        modified = True
        cx = src.center[1]+xmin
        cy = src.center[0]+ymin
        icx = int(np.round(cx))
        icy = int(np.round(cy))
        imbb = debResult.deblendedParents[debResult.filters[0]].img.getBBox()

        # Footprint must be inside the image
        if not imbb.contains(afwGeom.Point2I(cx, cy)):
            _setPeakError(debResult, log, pk, cx, cy, debResult.filters,
                          "peak center is not inside image", "setOutOfBounds")
            continue
        # Only save templates that have nonzero flux
        if np.sum(src.morph) == 0:
            _setPeakError(debResult, log, pk, cx, cy, debResult.filters,
                          "had no flux", "setFailedSymmetricTemplate")
            continue

        # Temporary for initial testing: combine multiple components
        model = blend.get_model(k=pk).astype(np.float32)

        # The peak in each band will have the same SpanSet
        mask = afwImage.Mask(np.array(np.sum(model, axis=0) > 0, dtype=np.int32), xy0=xy0)
        ss = afwGeom.SpanSet.fromMask(mask)

        if len(ss) == 0:
            log.warn("No flux in parent footprint")
            debResult.failed = True
            return False

        # Add the template footprint and image to the deblender result for each peak
        for fidx, f in enumerate(debResult.filters):
            pkResult = debResult.deblendedParents[f].peaks[pk]
            tfoot = afwDet.Footprint(ss, peakSchema=peakSchema)
            # Add the peak with the intensity of the centered model,
            # which might be slightly larger than the shifted model
            peakFlux = np.sum(src.sed[fidx]*src.morph[_cy, _cx])
            tfoot.addPeak(cx, cy, peakFlux)
            timg = afwImage.ImageF(model[fidx], xy0=xy0)
            timg = timg[tfoot.getBBox()]
            pkResult.setOrigTemplate(timg, tfoot)
            pkResult.setTemplate(timg, tfoot)
            pkResult.setFluxPortion(afwImage.MaskedImageF(timg))
            pkResult.multiColorPeak.x = cx
            pkResult.multiColorPeak.y = cy
            pkResult.peak.setFx(cx)
            pkResult.peak.setFy(cy)
            pkResult.peak.setIx(icx)
            pkResult.peak.setIy(icy)
    return modified

buildSymmetricTemplates()

def lsst.meas.deblender.plugins.buildSymmetricTemplates	(		debResult,
			log,
			patchEdges = False,
			setOrigTemplate = True
	)

Build a symmetric template for each peak in each filter

Given ``maskedImageF``, ``footprint``, and a ``DebldendedPeak``, creates a symmetric template
(``templateImage`` and ``templateFootprint``) around the peak for all peaks not flagged as
``skip`` or ``deblendedAsPsf``.

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.
patchEdges: `bool`, optional
    If True and if the parent Footprint touches pixels with the ``EDGE`` bit set,
    then grow the parent Footprint to include all symmetric templates.

Returns
-------
modified: `bool`
    If any peaks are not skipped or marked as point sources, ``modified`` is ``True.
    Otherwise ``modified`` is ``False``.

Definition at line 869 of file plugins.py.

def buildSymmetricTemplates(debResult, log, patchEdges=False, setOrigTemplate=True):
    """Build a symmetric template for each peak in each filter

    Given ``maskedImageF``, ``footprint``, and a ``DebldendedPeak``, creates a symmetric template
    (``templateImage`` and ``templateFootprint``) around the peak for all peaks not flagged as
    ``skip`` or ``deblendedAsPsf``.

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.
    patchEdges: `bool`, optional
        If True and if the parent Footprint touches pixels with the ``EDGE`` bit set,
        then grow the parent Footprint to include all symmetric templates.

    Returns
    -------
    modified: `bool`
        If any peaks are not skipped or marked as point sources, ``modified`` is ``True.
        Otherwise ``modified`` is ``False``.
    """
    modified = False
    # Create the Templates for each peak in each filter
    for fidx in debResult.filters:
        dp = debResult.deblendedParents[fidx]
        imbb = dp.img.getBBox()
        log.trace('Creating templates for footprint at x0,y0,W,H = %i, %i, %i, %i)', dp.x0, dp.y0, dp.W, dp.H)

        for peaki, pkres in enumerate(dp.peaks):
            log.trace('Deblending peak %i of %i', peaki, len(dp.peaks))
            # TODO: Check debResult to see if the peak is deblended as a point source
            # when comparing all bands, not just a single band
            if pkres.skip or pkres.deblendedAsPsf:
                continue
            modified = True
            pk = pkres.peak
            cx, cy = pk.getIx(), pk.getIy()
            if not imbb.contains(afwGeom.Point2I(cx, cy)):
                log.trace('Peak center is not inside image; skipping %i', pkres.pki)
                pkres.setOutOfBounds()
                continue
            log.trace('computing template for peak %i at (%i, %i)', pkres.pki, cx, cy)
            timg, tfoot, patched = bUtils.buildSymmetricTemplate(dp.maskedImage, dp.fp, pk, dp.avgNoise,
                                                                 True, patchEdges)
            if timg is None:
                log.trace('Peak %i at (%i, %i): failed to build symmetric template', pkres.pki, cx, cy)
                pkres.setFailedSymmetricTemplate()
                continue

            if patched:
                pkres.setPatched()

            # possibly save the original symmetric template
            if setOrigTemplate:
                pkres.setOrigTemplate(timg, tfoot)
            pkres.setTemplate(timg, tfoot)
    return modified

clipFootprintsToNonzero()

def lsst.meas.deblender.plugins.clipFootprintsToNonzero	(		debResult,
			log
	)

Clip non-zero spans in the template footprints for every peak in each filter.

Peak ``Footprint``s are clipped to the region in the image containing non-zero values
by dropping spans that are completely zero and moving endpoints to non-zero pixels
(but does not split spans that have internal zeros).

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.

Returns
-------
modified: `bool`
    Whether or not any templates were modified.
    This will be ``True`` as long as there is at least one source that is not flagged as a PSF.

Definition at line 1193 of file plugins.py.

def clipFootprintsToNonzero(debResult, log):
    """Clip non-zero spans in the template footprints for every peak in each filter.

    Peak ``Footprint``s are clipped to the region in the image containing non-zero values
    by dropping spans that are completely zero and moving endpoints to non-zero pixels
    (but does not split spans that have internal zeros).

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.

    Returns
    -------
    modified: `bool`
        Whether or not any templates were modified.
        This will be ``True`` as long as there is at least one source that is not flagged as a PSF.
    """
    # Loop over all filters
    for fidx in debResult.filters:
        dp = debResult.deblendedParents[fidx]
        for peaki, pkres in enumerate(dp.peaks):
            if pkres.skip or pkres.deblendedAsPsf:
                continue
            timg, tfoot = pkres.templateImage, pkres.templateFootprint
            clipFootprintToNonzeroImpl(tfoot, timg)
            if not tfoot.getBBox().isEmpty() and tfoot.getBBox() != timg.getBBox(afwImage.PARENT):
                timg = timg.Factory(timg, tfoot.getBBox(), afwImage.PARENT, True)
            pkres.setTemplate(timg, tfoot)
    return False

clipFootprintToNonzeroImpl()

def lsst.meas.deblender.plugins.clipFootprintToNonzeroImpl	(		foot,
			image
	)

 Clips the given *Footprint* to the region in the *Image*
 containing non-zero values.  The clipping drops spans that are
 totally zero, and moves endpoints to non-zero; it does not
 split spans that have internal zeros.

Definition at line 35 of file plugins.py.

def clipFootprintToNonzeroImpl(foot, image):
    '''
     Clips the given *Footprint* to the region in the *Image*
     containing non-zero values.  The clipping drops spans that are
     totally zero, and moves endpoints to non-zero; it does not
     split spans that have internal zeros.
    '''
    x0 = image.getX0()
    y0 = image.getY0()
    xImMax = x0 + image.getDimensions().getX()
    yImMax = y0 + image.getDimensions().getY()
    newSpans = []
    arr = image.getArray()
    for span in foot.spans:
        y = span.getY()
        if y < y0 or y > yImMax:
            continue
        spanX0 = span.getX0()
        spanX1 = span.getX1()
        xMin = spanX0 if spanX0 >= x0 else x0
        xMax = spanX1 if spanX1 <= xImMax else xImMax
        xarray = np.arange(xMin, xMax+1)[arr[y-y0, xMin-x0:xMax-x0+1] != 0]
        if len(xarray) > 0:
            newSpans.append(afwGeom.Span(y, xarray[0], xarray[-1]))
    # Time to update the SpanSet
    foot.setSpans(afwGeom.SpanSet(newSpans, normalize=False))
    foot.removeOrphanPeaks()

fitPsfs()

def lsst.meas.deblender.plugins.fitPsfs	(		debResult,
			log,
			psfChisqCut1 = 1.5,
			psfChisqCut2 = 1.5,
			psfChisqCut2b = 1.5,
			tinyFootprintSize = 2
	)

Fit a PSF + smooth background model (linear) to a small region around each peak

This function will iterate over all filters in deblender result but does not compare
results across filters.
DeblendedPeaks that pass the cuts have their templates modified to the PSF + background model
and their ``deblendedAsPsf`` property set to ``True``.

This will likely be replaced in the future with a function that compares the psf chi-squared cuts
so that peaks flagged as point sources will be considered point sources in all bands.

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.
psfChisqCut*: `float`, optional
    ``psfChisqCut1`` is the maximum chi-squared-per-degree-of-freedom allowed for a peak to
    be considered a PSF match without recentering.
    A fit is also made that includes terms to recenter the PSF.
    ``psfChisqCut2`` is the same as ``psfChisqCut1`` except it determines the restriction on the
    fit that includes recentering terms.
    If the peak is a match for a re-centered PSF, the PSF is repositioned at the new center and
    the peak footprint is fit again, this time to the new PSF.
    If the resulting chi-squared-per-degree-of-freedom is less than ``psfChisqCut2b`` then it
    passes the re-centering algorithm.
    If the peak passes both the re-centered and fixed position cuts, the better of the two is accepted,
    but parameters for all three psf fits are stored in the ``DebldendedPeak``.
    The default for ``psfChisqCut1``, ``psfChisqCut2``, and ``psfChisqCut2b`` is ``1.5``.
tinyFootprintSize: `float`, optional
    The PSF model is shrunk to the size that contains the original footprint.
    If the bbox of the clipped PSF model for a peak is smaller than ``max(tinyFootprintSize,2)``
    then ``tinyFootprint`` for the peak is set to ``True`` and the peak is not fit.
    The default is 2.

Returns
-------
modified: `bool`
    If any templates have been assigned to PSF point sources then ``modified`` is ``True``,
    otherwise it is ``False``.

Definition at line 334 of file plugins.py.

def fitPsfs(debResult, log, psfChisqCut1=1.5, psfChisqCut2=1.5, psfChisqCut2b=1.5, tinyFootprintSize=2):
    """Fit a PSF + smooth background model (linear) to a small region around each peak

    This function will iterate over all filters in deblender result but does not compare
    results across filters.
    DeblendedPeaks that pass the cuts have their templates modified to the PSF + background model
    and their ``deblendedAsPsf`` property set to ``True``.

    This will likely be replaced in the future with a function that compares the psf chi-squared cuts
    so that peaks flagged as point sources will be considered point sources in all bands.

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.
    psfChisqCut*: `float`, optional
        ``psfChisqCut1`` is the maximum chi-squared-per-degree-of-freedom allowed for a peak to
        be considered a PSF match without recentering.
        A fit is also made that includes terms to recenter the PSF.
        ``psfChisqCut2`` is the same as ``psfChisqCut1`` except it determines the restriction on the
        fit that includes recentering terms.
        If the peak is a match for a re-centered PSF, the PSF is repositioned at the new center and
        the peak footprint is fit again, this time to the new PSF.
        If the resulting chi-squared-per-degree-of-freedom is less than ``psfChisqCut2b`` then it
        passes the re-centering algorithm.
        If the peak passes both the re-centered and fixed position cuts, the better of the two is accepted,
        but parameters for all three psf fits are stored in the ``DebldendedPeak``.
        The default for ``psfChisqCut1``, ``psfChisqCut2``, and ``psfChisqCut2b`` is ``1.5``.
    tinyFootprintSize: `float`, optional
        The PSF model is shrunk to the size that contains the original footprint.
        If the bbox of the clipped PSF model for a peak is smaller than ``max(tinyFootprintSize,2)``
        then ``tinyFootprint`` for the peak is set to ``True`` and the peak is not fit.
        The default is 2.

    Returns
    -------
    modified: `bool`
        If any templates have been assigned to PSF point sources then ``modified`` is ``True``,
        otherwise it is ``False``.
    """
    from .baseline import CachingPsf
    modified = False
    # Loop over all of the filters to build the PSF
    for fidx in debResult.filters:
        dp = debResult.deblendedParents[fidx]
        peaks = dp.fp.getPeaks()
        cpsf = CachingPsf(dp.psf)

        # create mask image for pixels within the footprint
        fmask = afwImage.Mask(dp.bb)
        fmask.setXY0(dp.bb.getMinX(), dp.bb.getMinY())
        dp.fp.spans.setMask(fmask, 1)

        # pk.getF() -- retrieving the floating-point location of the peak
        # -- actually shows up in the profile if we do it in the loop, so
        # grab them all here.
        peakF = [pk.getF() for pk in peaks]

        for pki, (pk, pkres, pkF) in enumerate(zip(peaks, dp.peaks, peakF)):
            log.trace('Filter %s, Peak %i', fidx, pki)
            ispsf = _fitPsf(dp.fp, fmask, pk, pkF, pkres, dp.bb, peaks, peakF, log, cpsf, dp.psffwhm,
                            dp.img, dp.varimg, psfChisqCut1, psfChisqCut2, psfChisqCut2b, tinyFootprintSize)
            modified = modified or ispsf
    return modified

makeTemplatesMonotonic()

def lsst.meas.deblender.plugins.makeTemplatesMonotonic	(		debResult,
			log
	)

Make the templates monotonic.

The pixels in the templates are modified such that pixels further from the peak will
have values smaller than those closer to the peak.

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.

Returns
-------
modified: `bool`
    Whether or not any templates were modified.
    This will be ``True`` as long as there is at least one source that is not flagged as a PSF.

Definition at line 1158 of file plugins.py.

def makeTemplatesMonotonic(debResult, log):
    """Make the templates monotonic.

    The pixels in the templates are modified such that pixels further from the peak will
    have values smaller than those closer to the peak.

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.

    Returns
    -------
    modified: `bool`
        Whether or not any templates were modified.
        This will be ``True`` as long as there is at least one source that is not flagged as a PSF.
    """
    modified = False
    # Loop over all filters
    for fidx in debResult.filters:
        dp = debResult.deblendedParents[fidx]
        for peaki, pkres in enumerate(dp.peaks):
            if pkres.skip or pkres.deblendedAsPsf:
                continue
            modified = True
            timg, tfoot = pkres.templateImage, pkres.templateFootprint
            pk = pkres.peak
            log.trace('Making template %i monotonic', pkres.pki)
            bUtils.makeMonotonic(timg, pk)
            pkres.setTemplate(timg, tfoot)
    return modified

medianSmoothTemplates()

def lsst.meas.deblender.plugins.medianSmoothTemplates	(		debResult,
			log,
			medianFilterHalfsize = 2
	)

Applying median smoothing filter to the template images for every peak in every filter.

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.
medianFilterHalfSize: `int`, optional
    Half the box size of the median filter, i.e. a ``medianFilterHalfSize`` of 50 means that
    each output pixel will be the median of  the pixels in a 101 x 101-pixel box in the input image.
    This parameter is only used when ``medianSmoothTemplate==True``, otherwise it is ignored.

Returns
-------
modified: `bool`
    Whether or not any templates were modified.
    This will be ``True`` as long as there is at least one source that is not flagged as a PSF.

Definition at line 1113 of file plugins.py.

def medianSmoothTemplates(debResult, log, medianFilterHalfsize=2):
    """Applying median smoothing filter to the template images for every peak in every filter.

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.
    medianFilterHalfSize: `int`, optional
        Half the box size of the median filter, i.e. a ``medianFilterHalfSize`` of 50 means that
        each output pixel will be the median of  the pixels in a 101 x 101-pixel box in the input image.
        This parameter is only used when ``medianSmoothTemplate==True``, otherwise it is ignored.

    Returns
    -------
    modified: `bool`
        Whether or not any templates were modified.
        This will be ``True`` as long as there is at least one source that is not flagged as a PSF.
    """
    modified = False
    # Loop over all filters
    for fidx in debResult.filters:
        dp = debResult.deblendedParents[fidx]
        for peaki, pkres in enumerate(dp.peaks):
            if pkres.skip or pkres.deblendedAsPsf:
                continue
            modified = True
            timg, tfoot = pkres.templateImage, pkres.templateFootprint
            filtsize = medianFilterHalfsize*2 + 1
            if timg.getWidth() >= filtsize and timg.getHeight() >= filtsize:
                log.trace('Median filtering template %i', pkres.pki)
                # We want the output to go in "t1", so copy it into
                # "inimg" for input
                inimg = timg.Factory(timg, True)
                bUtils.medianFilter(inimg, timg, medianFilterHalfsize)
                # possible save this median-filtered template
                pkres.setMedianFilteredTemplate(timg, tfoot)
            else:
                log.trace('Not median-filtering template %i: size %i x %i smaller than required %i x %i',
                          pkres.pki, timg.getWidth(), timg.getHeight(), filtsize, filtsize)
            pkres.setTemplate(timg, tfoot)
    return modified

rampFluxAtEdge()

def lsst.meas.deblender.plugins.rampFluxAtEdge	(		debResult,
			log,
			patchEdges = False
	)

Adjust flux on the edges of the template footprints.

Using the PSF, a peak ``Footprint`` with pixels on the edge of ``footprint``
is grown by the ``psffwhm``*1.5 and filled in with ramped pixels.
The result is a new symmetric footprint template for the peaks near the edge.

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.
patchEdges: `bool`, optional
    If True and if the parent Footprint touches pixels with the ``EDGE`` bit set,
    then grow the parent Footprint to include all symmetric templates.

Returns
-------
modified: `bool`
    If any peaks have their templates modified to include flux at the edges,
    ``modified`` is ``True``.

Definition at line 930 of file plugins.py.

def rampFluxAtEdge(debResult, log, patchEdges=False):
    """Adjust flux on the edges of the template footprints.

    Using the PSF, a peak ``Footprint`` with pixels on the edge of ``footprint``
    is grown by the ``psffwhm``*1.5 and filled in with ramped pixels.
    The result is a new symmetric footprint template for the peaks near the edge.

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.
    patchEdges: `bool`, optional
        If True and if the parent Footprint touches pixels with the ``EDGE`` bit set,
        then grow the parent Footprint to include all symmetric templates.

    Returns
    -------
    modified: `bool`
        If any peaks have their templates modified to include flux at the edges,
        ``modified`` is ``True``.
    """
    modified = False
    # Loop over all filters
    for fidx in debResult.filters:
        dp = debResult.deblendedParents[fidx]
        log.trace('Checking for significant flux at edge: sigma1=%g', dp.avgNoise)

        for peaki, pkres in enumerate(dp.peaks):
            if pkres.skip or pkres.deblendedAsPsf:
                continue
            timg, tfoot = pkres.templateImage, pkres.templateFootprint
            if bUtils.hasSignificantFluxAtEdge(timg, tfoot, 3*dp.avgNoise):
                log.trace("Template %i has significant flux at edge: ramping", pkres.pki)
                try:
                    (timg2, tfoot2, patched) = _handle_flux_at_edge(log, dp.psffwhm, timg, tfoot, dp.fp,
                                                                    dp.maskedImage, dp.x0, dp.x1,
                                                                    dp.y0, dp.y1, dp.psf, pkres.peak,
                                                                    dp.avgNoise, patchEdges)
                except lsst.pex.exceptions.Exception as exc:
                    if (isinstance(exc, lsst.pex.exceptions.InvalidParameterError) and
                            "CoaddPsf" in str(exc)):
                        pkres.setOutOfBounds()
                        continue
                    raise
                pkres.setRampedTemplate(timg2, tfoot2)
                if patched:
                    pkres.setPatched()
                pkres.setTemplate(timg2, tfoot2)
                modified = True
    return modified

reconstructTemplates()

def lsst.meas.deblender.plugins.reconstructTemplates	(		debResult,
			log,
			maxTempDotProd = 0.5
	)

Remove "degenerate templates"

If galaxies have substructure, such as face-on spirals, the process of identifying peaks can
"shred" the galaxy into many pieces. The templates of shredded galaxies are typically quite
similar because they represent the same galaxy, so we try to identify these "degenerate" peaks
by looking at the inner product (in pixel space) of pairs of templates.
If they are nearly parallel, we only keep one of the peaks and reject the other.
If only one of the peaks is a PSF template, the other template is used,
otherwise the one with the maximum template value is kept.

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.
maxTempDotProd: `float`, optional
    All dot products between templates greater than ``maxTempDotProd`` will result in one
    of the templates removed.

Returns
-------
modified: `bool`
    If any degenerate templates are found, ``modified`` is ``True``.

Definition at line 1296 of file plugins.py.

def reconstructTemplates(debResult, log, maxTempDotProd=0.5):
    """Remove "degenerate templates"

    If galaxies have substructure, such as face-on spirals, the process of identifying peaks can
    "shred" the galaxy into many pieces. The templates of shredded galaxies are typically quite
    similar because they represent the same galaxy, so we try to identify these "degenerate" peaks
    by looking at the inner product (in pixel space) of pairs of templates.
    If they are nearly parallel, we only keep one of the peaks and reject the other.
    If only one of the peaks is a PSF template, the other template is used,
    otherwise the one with the maximum template value is kept.

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.
    maxTempDotProd: `float`, optional
        All dot products between templates greater than ``maxTempDotProd`` will result in one
        of the templates removed.

    Returns
    -------
    modified: `bool`
        If any degenerate templates are found, ``modified`` is ``True``.
    """
    log.trace('Looking for degnerate templates')

    foundReject = False
    for fidx in debResult.filters:
        dp = debResult.deblendedParents[fidx]
        nchild = np.sum([pkres.skip is False for pkres in dp.peaks])
        indexes = [pkres.pki for pkres in dp.peaks if pkres.skip is False]

        # We build a matrix that stores the dot product between templates.
        # We convert the template images to HeavyFootprints because they already have a method
        # to compute the dot product.
        A = np.zeros((nchild, nchild))
        maxTemplate = []
        heavies = []
        for pkres in dp.peaks:
            if pkres.skip:
                continue
            heavies.append(afwDet.makeHeavyFootprint(pkres.templateFootprint,
                                                     afwImage.MaskedImageF(pkres.templateImage)))
            maxTemplate.append(np.max(pkres.templateImage.getArray()))

        for i in range(nchild):
            for j in range(i + 1):
                A[i, j] = heavies[i].dot(heavies[j])

        # Normalize the dot products to get the cosine of the angle between templates
        for i in range(nchild):
            for j in range(i):
                norm = A[i, i]*A[j, j]
                if norm <= 0:
                    A[i, j] = 0
                else:
                    A[i, j] /= np.sqrt(norm)

        # Iterate over pairs of objects and find the maximum non-diagonal element of the matrix.
        # Exit the loop once we find a single degenerate pair greater than the threshold.
        rejectedIndex = -1
        for i in range(nchild):
            currentMax = 0.
            for j in range(i):
                if A[i, j] > currentMax:
                    currentMax = A[i, j]
                    if currentMax > maxTempDotProd:
                        foundReject = True
                        rejectedIndex = j

            if foundReject:
                break

        del A

        # If one of the objects is identified as a PSF keep the other one, otherwise keep the one
        # with the maximum template value
        if foundReject:
            keep = indexes[i]
            reject = indexes[rejectedIndex]
            if dp.peaks[keep].deblendedAsPsf and dp.peaks[reject].deblendedAsPsf is False:
                keep = indexes[rejectedIndex]
                reject = indexes[i]
            elif dp.peaks[keep].deblendedAsPsf is False and dp.peaks[reject].deblendedAsPsf:
                reject = indexes[rejectedIndex]
                keep = indexes[i]
            else:
                if maxTemplate[rejectedIndex] > maxTemplate[i]:
                    keep = indexes[rejectedIndex]
                    reject = indexes[i]
            log.trace('Removing object with index %d : %f.  Degenerate with %d' % (reject, currentMax,
                                                                                   keep))
            dp.peaks[reject].skip = True
            dp.peaks[reject].degenerate = True

    return foundReject

weightTemplates()

def lsst.meas.deblender.plugins.weightTemplates	(		debResult,
			log
	)

Weight the templates to best fit the observed image in each filter

This function re-weights the templates so that their linear combination best represents
the observed image in that filter.
In the future it may be useful to simultaneously weight all of the filters together.

Parameters
----------
debResult: `lsst.meas.deblender.baseline.DeblenderResult`
    Container for the final deblender results.
log: `log.Log`
    LSST logger for logging purposes.

Returns
-------
modified: `bool`
    ``weightTemplates`` does not actually modify the ``Footprint`` templates other than
    to add a weight to them, so ``modified`` is always ``False``.

Definition at line 1227 of file plugins.py.

def weightTemplates(debResult, log):
    """Weight the templates to best fit the observed image in each filter

    This function re-weights the templates so that their linear combination best represents
    the observed image in that filter.
    In the future it may be useful to simultaneously weight all of the filters together.

    Parameters
    ----------
    debResult: `lsst.meas.deblender.baseline.DeblenderResult`
        Container for the final deblender results.
    log: `log.Log`
        LSST logger for logging purposes.

    Returns
    -------
    modified: `bool`
        ``weightTemplates`` does not actually modify the ``Footprint`` templates other than
        to add a weight to them, so ``modified`` is always ``False``.
    """
    # Weight the templates by doing a least-squares fit to the image
    log.trace('Weighting templates')
    for fidx in debResult.filters:
        _weightTemplates(debResult.deblendedParents[fidx])
    return False

---

Generated on Thu Aug 8 2019 20:21:22 for LSSTApplications by   1.8.13