Classes
class	DeblenderResult

class	DeblendedParent

class	MultiColorPeak

class	DeblendedPeak

class	CachingPsf

Functions
def	deblend (footprint, maskedImage, psf, psffwhm, psfChisqCut1=1.5, psfChisqCut2=1.5, psfChisqCut2b=1.5, fitPsfs=True, medianSmoothTemplate=True, medianFilterHalfsize=2, monotonicTemplate=True, weightTemplates=False, log=None, verbose=False, sigma1=None, maxNumberOfPeaks=0, assignStrayFlux=True, strayFluxToPointSources='necessary', strayFluxAssignment='r-to-peak', rampFluxAtEdge=False, patchEdges=False, tinyFootprintSize=2, getTemplateSum=False, clipStrayFluxFraction=0.001, clipFootprintToNonzero=True, removeDegenerateTemplates=False, maxTempDotProd=0.5)

def	newDeblend (debPlugins, footprint, mMaskedImage, psfs, psfFwhms, log=None, verbose=False, avgNoise=None, maxNumberOfPeaks=0)

Variables
list	DEFAULT_PLUGINS

Function Documentation

◆ deblend()

def lsst.meas.deblender.baseline.deblend	(	footprint,
		maskedImage,
		psf,
		psffwhm,
		psfChisqCut1 = `1.5`,
		psfChisqCut2 = `1.5`,
		psfChisqCut2b = `1.5`,
		fitPsfs = `True`,
		medianSmoothTemplate = `True`,
		medianFilterHalfsize = `2`,
		monotonicTemplate = `True`,
		weightTemplates = `False`,
		log = `None`,
		verbose = `False`,
		sigma1 = `None`,
		maxNumberOfPeaks = `0`,
		assignStrayFlux = `True`,
		strayFluxToPointSources = `'necessary'`,
		strayFluxAssignment = `'r-to-peak'`,
		rampFluxAtEdge = `False`,
		patchEdges = `False`,
		tinyFootprintSize = `2`,
		getTemplateSum = `False`,
		clipStrayFluxFraction = `0.001`,
		clipFootprintToNonzero = `True`,
		removeDegenerateTemplates = `False`,
		maxTempDotProd = `0.5`
	)

Deblend a parent ``Footprint`` in a ``MaskedImageF``.

Deblending assumes that ``footprint`` has multiple peaks, as it will still create a
`PerFootprint` object with a list of peaks even if there is only one peak in the list.
It is recommended to first check that ``footprint`` has more than one peak, similar to the
execution of `lsst.meas.deblender.deblend.SourceDeblendTask`.

.. note::
This is the API for the old deblender, however the function builds the plugins necessary
to use the new deblender to perform identically to the old deblender.
To test out newer functionality use ``newDeblend`` instead.

Deblending involves several mandatory and optional steps:

# Optional: If ``fitPsfs`` is True, find all peaks that are well-fit by a PSF + background model

* Peaks that pass the cuts have their footprints modified to the PSF + background model
and their ``deblendedAsPsf`` property set to ``True``.
* Relevant parameters: ``psfChisqCut1``, ``psfChisqCut2``, ``psfChisqCut2b``,
``tinyFootprintSize``.
* See the parameter descriptions for more.

# Build a symmetric template for each peak not well-fit by the PSF model

* Given ``maskedImageF``, ``footprint``, and a ``DeblendedPeak``, creates a symmetric
template (``templateImage`` and ``templateFootprint``) around the peak
for all peaks not flagged as ``skip`` or ``deblendedAsPsf``.
* If ``patchEdges=True`` and if ``footprint`` touches pixels with the
``EDGE`` bit set, then ``footprint`` is grown to include spans whose
symmetric mirror is outside of the image.
* Relevant parameters: ``sigma1`` and ``patchEdges``.

# Optional: If ``rampFluxAtEdge`` is True, adjust flux on the edges of the template footprints

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

# Optionally (``medianSmoothTemplate=True``) filter the template images

* Apply a median smoothing filter to all of the template images.
* Relevant parameters: ``medianFilterHalfSize``

# Optional: If ``monotonicTemplate`` is True, 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.

# Optional: If ``clipFootprintToNonzero`` is True, clip non-zero spans in the template footprints

* 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).

# Optional: If ``weightTemplates`` is True, weight the templates to best fit the observed image

* Re-weight the templates so that their linear combination
best represents the observed ``maskedImage``

# Optional: If ``removeDegenerateTempaltes`` is True, reconstruct shredded galaxies

* 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.
* Relevant parameters: ``maxTempDotProduct``

# Apportion flux to all of the peak templates

* Divide the ``maskedImage`` flux amongst all of the templates based on the fraction of
flux assigned to each ``tempalteFootprint``.
* Leftover "stray flux" is assigned to peaks based on the other parameters.
* Relevant parameters: ``clipStrayFluxFraction``, ``strayFluxAssignment``,
``strayFluxToPointSources``, ``assignStrayFlux``

Parameters
----------
footprint: `afw.detection.Footprint`
Parent footprint to deblend
maskedImage: `afw.image.MaskedImageF`
Masked image containing the ``footprint``
psf: `afw.detection.Psf`
Psf of the ``maskedImage``
psffwhm: `float`
FWHM of the ``maskedImage``\'s ``psf``
psfChisqCut*: `float`, optional
If ``fitPsfs==True``, all of the peaks are fit to the image PSF.
``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 ``DeblendedPeak``.
The default for ``psfChisqCut1``, ``psfChisqCut2``, and ``psfChisqCut2b`` is ``1.5``.
fitPsfs: `bool`, optional
If True then all of the peaks will be compared to the image PSF to
distinguish stars from galaxies.
medianSmoothTemplate: ``bool``, optional
If ``medianSmoothTemplate==True`` it a median smoothing filter is applied to the ``maskedImage``.
The default is ``True``.
medianFilterHalfSize: `int`, optional
Half the box size of the median filter, ie 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.
The default value is 2.
monotonicTempalte: `bool`, optional
If True then make the template monotonic.
The default is True.
weightTemplates: `bool`, optional
If True, re-weight the templates so that their linear combination best represents
the observed ``maskedImage``.
The default is False.
log: `log.Log`, optional
LSST logger for logging purposes.
The default is ``None`` (no logging).
verbose: `bool`, optional
Whether or not to show a more verbose output.
The default is ``False``.
sigma1: `float`, optional
Average noise level in ``maskedImage``.
The default is ``None``, which estimates the noise from the median value of ``maskedImage``.
maxNumberOfPeaks: `int`, optional
If nonzero, 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.
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``.
The default is True.
strayFluxToPointSources: `string`
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

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

rampFluxAtEdge: `bool`, optional
If True then extend footprints with excessive flux on the edges as described above.
The default is False.
patchEdges: `bool`, optional
If True and if the footprint touches pixels with the ``EDGE`` bit set,
then grow the footprint to include all symmetric templates.
The default is ``False``.
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.
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 `PerFootprint`).
The default is False.
clipStrayFluxFraction: `float`, optional
Minimum stray-flux portion.
Any stray-flux portion less than ``clipStrayFluxFraction`` is clipped to zero.
The default is 0.001.
clipFootprintToNonzero: `bool`, optional
If True then clip non-zero spans in the template footprints. See above for more.
The default is True.
removeDegenerateTemplates: `bool`, optional
If True then we try to identify "degenerate" peaks by looking at the inner product
(in pixel space) of pairs of templates.
The default is False.
maxTempDotProduct: `float`, optional
All dot products between templates greater than ``maxTempDotProduct`` will result in one
of the templates removed. This parameter is only used when ``removeDegenerateTempaltes==True``.
The default is 0.5.

Returns
-------
res: `PerFootprint`
Deblender result that contains a list of ``DeblendedPeak``\ s for each peak and (optionally)
the template sum.

Definition at line 430 of file baseline.py.

             ):
     r"""Deblend a parent ``Footprint`` in a ``MaskedImageF``.
  
     Deblending assumes that ``footprint`` has multiple peaks, as it will still create a
     `PerFootprint` object with a list of peaks even if there is only one peak in the list.
     It is recommended to first check that ``footprint`` has more than one peak, similar to the
     execution of `lsst.meas.deblender.deblend.SourceDeblendTask`.
  
     .. note::
         This is the API for the old deblender, however the function builds the plugins necessary
         to use the new deblender to perform identically to the old deblender.
         To test out newer functionality use ``newDeblend`` instead.
  
     Deblending involves several mandatory and optional steps:
  
     # Optional: If ``fitPsfs`` is True, find all peaks that are well-fit by a PSF + background model
  
         * Peaks that pass the cuts have their footprints modified to the PSF + background model
           and their ``deblendedAsPsf`` property set to ``True``.
         * Relevant parameters: ``psfChisqCut1``, ``psfChisqCut2``, ``psfChisqCut2b``,
           ``tinyFootprintSize``.
         * See the parameter descriptions for more.
  
     # Build a symmetric template for each peak not well-fit by the PSF model
  
         * Given ``maskedImageF``, ``footprint``, and a ``DeblendedPeak``, creates a symmetric
           template (``templateImage`` and ``templateFootprint``) around the peak
           for all peaks not flagged as ``skip`` or ``deblendedAsPsf``.
         * If ``patchEdges=True`` and if ``footprint`` touches pixels with the
           ``EDGE`` bit set, then ``footprint`` is grown to include spans whose
           symmetric mirror is outside of the image.
         * Relevant parameters: ``sigma1`` and ``patchEdges``.
  
     # Optional: If ``rampFluxAtEdge`` is True, adjust flux on the edges of the template footprints
  
         * Using the PSF, a peak ``Footprint`` with pixels on the edge of of ``footprint``
           is grown by the psffwhm*1.5 and filled in with zeros.
         * The result is a new symmetric footprint template for the peaks near the edge.
         * Relevant parameter: ``patchEdges``.
  
     # Optionally (``medianSmoothTemplate=True``) filter the template images
  
         * Apply a median smoothing filter to all of the template images.
         * Relevant parameters: ``medianFilterHalfSize``
  
     # Optional: If ``monotonicTemplate`` is True, 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.
  
     # Optional: If ``clipFootprintToNonzero`` is True, clip non-zero spans in the template footprints
  
         * 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).
  
     # Optional: If ``weightTemplates`` is True,  weight the templates to best fit the observed image
  
         * Re-weight the templates so that their linear combination
           best represents the observed ``maskedImage``
  
     # Optional: If ``removeDegenerateTempaltes`` is True, reconstruct shredded galaxies
  
         * 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.
         * Relevant parameters: ``maxTempDotProduct``
  
     # Apportion flux to all of the peak templates
  
         * Divide the ``maskedImage`` flux amongst all of the templates based on the fraction of
           flux assigned to each ``tempalteFootprint``.
         * Leftover "stray flux" is assigned to peaks based on the other parameters.
         * Relevant parameters: ``clipStrayFluxFraction``, ``strayFluxAssignment``,
           ``strayFluxToPointSources``, ``assignStrayFlux``
  
     Parameters
     ----------
     footprint: `afw.detection.Footprint`
         Parent footprint to deblend
     maskedImage: `afw.image.MaskedImageF`
         Masked image containing the ``footprint``
     psf: `afw.detection.Psf`
         Psf of the ``maskedImage``
     psffwhm: `float`
         FWHM of the ``maskedImage``\'s ``psf``
     psfChisqCut*: `float`, optional
         If ``fitPsfs==True``, all of the peaks are fit to the image PSF.
         ``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 ``DeblendedPeak``.
         The default for ``psfChisqCut1``, ``psfChisqCut2``, and ``psfChisqCut2b`` is ``1.5``.
     fitPsfs: `bool`, optional
         If True then all of the peaks will be compared to the image PSF to
         distinguish stars from galaxies.
     medianSmoothTemplate: ``bool``, optional
         If ``medianSmoothTemplate==True`` it a median smoothing filter is applied to the ``maskedImage``.
         The default is ``True``.
     medianFilterHalfSize: `int`, optional
         Half the box size of the median filter, ie 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.
         The default value is 2.
     monotonicTempalte: `bool`, optional
         If True then make the template monotonic.
         The default is True.
     weightTemplates: `bool`, optional
         If True, re-weight the templates so that their linear combination best represents
         the observed ``maskedImage``.
         The default is False.
     log: `log.Log`, optional
         LSST logger for logging purposes.
         The default is ``None`` (no logging).
     verbose: `bool`, optional
         Whether or not to show a more verbose output.
         The default is ``False``.
     sigma1: `float`, optional
         Average noise level in ``maskedImage``.
         The default is ``None``, which estimates the noise from the median value of ``maskedImage``.
     maxNumberOfPeaks: `int`, optional
         If nonzero, 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.
     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``.
         The default is True.
     strayFluxToPointSources: `string`
         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
  
     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
  
     rampFluxAtEdge: `bool`, optional
         If True then extend footprints with excessive flux on the edges as described above.
         The default is False.
     patchEdges: `bool`, optional
         If True and if the footprint touches pixels with the ``EDGE`` bit set,
         then grow the footprint to include all symmetric templates.
         The default is ``False``.
     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.
     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 `PerFootprint`).
         The default is False.
     clipStrayFluxFraction: `float`, optional
         Minimum stray-flux portion.
         Any stray-flux portion less than ``clipStrayFluxFraction`` is clipped to zero.
         The default is 0.001.
     clipFootprintToNonzero: `bool`, optional
         If True then clip non-zero spans in the template footprints. See above for more.
         The default is True.
     removeDegenerateTemplates: `bool`, optional
         If True then we try to identify "degenerate" peaks by looking at the inner product
         (in pixel space) of pairs of templates.
         The default is False.
     maxTempDotProduct: `float`, optional
         All dot products between templates greater than ``maxTempDotProduct`` will result in one
         of the templates removed. This parameter is only used when ``removeDegenerateTempaltes==True``.
         The default is 0.5.
  
     Returns
     -------
     res: `PerFootprint`
         Deblender result that contains a list of ``DeblendedPeak``\ s for each peak and (optionally)
         the template sum.
     """
     avgNoise = sigma1
  
     debPlugins = []
  
     # Add activated deblender plugins
     if fitPsfs:
         debPlugins.append(plugins.DeblenderPlugin(plugins.fitPsfs,
                                                   psfChisqCut1=psfChisqCut1,
                                                   psfChisqCut2=psfChisqCut2,
                                                   psfChisqCut2b=psfChisqCut2b,
                                                   tinyFootprintSize=tinyFootprintSize))
     debPlugins.append(plugins.DeblenderPlugin(plugins.buildSymmetricTemplates, patchEdges=patchEdges))
     if rampFluxAtEdge:
         debPlugins.append(plugins.DeblenderPlugin(plugins.rampFluxAtEdge, patchEdges=patchEdges))
     if medianSmoothTemplate:
         debPlugins.append(plugins.DeblenderPlugin(plugins.medianSmoothTemplates,
                                                   medianFilterHalfsize=medianFilterHalfsize))
     if monotonicTemplate:
         debPlugins.append(plugins.DeblenderPlugin(plugins.makeTemplatesMonotonic))
     if clipFootprintToNonzero:
         debPlugins.append(plugins.DeblenderPlugin(plugins.clipFootprintsToNonzero))
     if weightTemplates:
         debPlugins.append(plugins.DeblenderPlugin(plugins.weightTemplates))
     if removeDegenerateTemplates:
         if weightTemplates:
             onReset = len(debPlugins)-1
         else:
             onReset = len(debPlugins)
         debPlugins.append(plugins.DeblenderPlugin(plugins.reconstructTemplates,
                                                   onReset=onReset,
                                                   maxTempDotProd=maxTempDotProd))
     debPlugins.append(plugins.DeblenderPlugin(plugins.apportionFlux,
                                               clipStrayFluxFraction=clipStrayFluxFraction,
                                               assignStrayFlux=assignStrayFlux,
                                               strayFluxAssignment=strayFluxAssignment,
                                               strayFluxToPointSources=strayFluxToPointSources,
                                               getTemplateSum=getTemplateSum))
  
     debResult = newDeblend(debPlugins, footprint, maskedImage, psf, psffwhm, log, verbose, avgNoise)
  
     return debResult
  
  

◆ newDeblend()

def lsst.meas.deblender.baseline.newDeblend	(	debPlugins,
		footprint,
		mMaskedImage,
		psfs,
		psfFwhms,
		log = `None`,
		verbose = `False`,
		avgNoise = `None`,
		maxNumberOfPeaks = `0`
	)

Deblend a parent ``Footprint`` in a ``MaskedImageF``.

Deblending assumes that ``footprint`` has multiple peaks, as it will still create a
`PerFootprint` object with a list of peaks even if there is only one peak in the list.
It is recommended to first check that ``footprint`` has more than one peak, similar to the
execution of `lsst.meas.deblender.deblend.SourceDeblendTask`.

This version of the deblender accepts a list of plugins to execute, with the option to re-run parts
of the deblender if templates are changed during any of the steps.

Parameters
----------
debPlugins: list of `meas.deblender.plugins.DeblenderPlugins`
Plugins to execute (in order of execution) for the deblender.
footprint: `afw.detection.Footprint` or list of Footprints
Parent footprint to deblend.
mMaskedImage: `MultibandMaskedImage` or `MaskedImage`
Masked image in each band.
psfs: `afw.detection.Psf` or list of Psfs
Psf of the ``maskedImage``.
psfFwhms: `float` or list of floats
FWHM of the ``maskedImage``\'s ``psf``.
log: `log.Log`, optional
LSST logger for logging purposes.
The default is ``None`` (no logging).
verbose: `bool`, optional
Whether or not to show a more verbose output.
The default is ``False``.
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.
maxNumberOfPeaks: `int`, optional
If nonzero, 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.

Returns
-------
debResult: `DeblendedParent`
Deblender result that contains a list of ``MultiColorPeak``\ s for each peak and
information that describes the footprint in all filters.

Definition at line 678 of file baseline.py.

                log=None, verbose=False, avgNoise=None, maxNumberOfPeaks=0):
     r"""Deblend a parent ``Footprint`` in a ``MaskedImageF``.
  
     Deblending assumes that ``footprint`` has multiple peaks, as it will still create a
     `PerFootprint` object with a list of peaks even if there is only one peak in the list.
     It is recommended to first check that ``footprint`` has more than one peak, similar to the
     execution of `lsst.meas.deblender.deblend.SourceDeblendTask`.
  
     This version of the deblender accepts a list of plugins to execute, with the option to re-run parts
     of the deblender if templates are changed during any of the steps.
  
     Parameters
     ----------
     debPlugins: list of `meas.deblender.plugins.DeblenderPlugins`
         Plugins to execute (in order of execution) for the deblender.
     footprint: `afw.detection.Footprint` or list of Footprints
         Parent footprint to deblend.
     mMaskedImage: `MultibandMaskedImage` or `MaskedImage`
         Masked image in each band.
     psfs: `afw.detection.Psf` or list of Psfs
         Psf of the ``maskedImage``.
     psfFwhms: `float` or list of floats
         FWHM of the ``maskedImage``\'s ``psf``.
     log: `log.Log`, optional
         LSST logger for logging purposes.
         The default is ``None`` (no logging).
     verbose: `bool`, optional
         Whether or not to show a more verbose output.
         The default is ``False``.
     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.
     maxNumberOfPeaks: `int`, optional
         If nonzero, 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.
  
     Returns
     -------
     debResult: `DeblendedParent`
         Deblender result that contains a list of ``MultiColorPeak``\ s for each peak and
         information that describes the footprint in all filters.
     """
     # Import C++ routines
  
     if log is None:
         import lsst.log as lsstLog
  
         log = lsstLog.Log.getLogger(__name__)
  
         if verbose:
             log.setLevel(lsstLog.Log.TRACE)
  
     # get object that will hold our results
     debResult = DeblenderResult(footprint, mMaskedImage, psfs, psfFwhms, log,
                                 maxNumberOfPeaks=maxNumberOfPeaks, avgNoise=avgNoise)
  
     step = 0
     while step < len(debPlugins):
         # If a failure occurs at any step,
         # the result is flagged as `failed`
         # and the remaining steps are skipped
         if not debResult.failed:
             reset = debPlugins[step].run(debResult, log)
         else:
             log.warning("Skipping steps %s", debPlugins[step:])
             return debResult
         if reset:
             step = debPlugins[step].onReset
         else:
             step += 1
  
     return debResult
  
  

Variable Documentation

◆ DEFAULT_PLUGINS

list lsst.meas.deblender.baseline.DEFAULT_PLUGINS

Initial value:

 =  [
     plugins.DeblenderPlugin(plugins.fitPsfs),
     plugins.DeblenderPlugin(plugins.buildSymmetricTemplates),
     plugins.DeblenderPlugin(plugins.medianSmoothTemplates),
     plugins.DeblenderPlugin(plugins.makeTemplatesMonotonic),
     plugins.DeblenderPlugin(plugins.clipFootprintsToNonzero),
     plugins.DeblenderPlugin(plugins.reconstructTemplates, onReset=5),
     plugins.DeblenderPlugin(plugins.apportionFlux),
 ]

Definition at line 36 of file baseline.py.

Classes

Functions

Variables

Function Documentation

◆ deblend()

◆ newDeblend()

Variable Documentation

◆ DEFAULT_PLUGINS