lsst.ip.diffim  21.0.0-16-gec61338+5610ae7019
Public Member Functions | Public Attributes | Static Public Attributes | List of all members
lsst.ip.diffim.zogy.ZogyImagePsfMatchTask Class Reference
Inheritance diagram for lsst.ip.diffim.zogy.ZogyImagePsfMatchTask:
lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask lsst.ip.diffim.psfMatch.PsfMatchTask

Public Member Functions

def __init__ (self, *args, **kwargs)
 
def run (self, scienceExposure, templateExposure, doWarping=True)
 
def subtractExposures (self, templateExposure, scienceExposure, *args)
 
def subtractMaskedImages (self, templateExposure, scienceExposure, *args)
 
def getFwhmPix (self, psf)
 
def matchExposures (self, templateExposure, scienceExposure, templateFwhmPix=None, scienceFwhmPix=None, candidateList=None, doWarping=True, convolveTemplate=True)
 
def matchMaskedImages (self, templateMaskedImage, scienceMaskedImage, candidateList, templateFwhmPix=None, scienceFwhmPix=None)
 
def subtractExposures (self, templateExposure, scienceExposure, templateFwhmPix=None, scienceFwhmPix=None, candidateList=None, doWarping=True, convolveTemplate=True)
 
def subtractMaskedImages (self, templateMaskedImage, scienceMaskedImage, candidateList, templateFwhmPix=None, scienceFwhmPix=None)
 
def getSelectSources (self, exposure, sigma=None, doSmooth=True, idFactory=None)
 
def makeCandidateList (self, templateExposure, scienceExposure, kernelSize, candidateList=None)
 

Public Attributes

 kConfig
 
 background
 
 selectSchema
 
 selectAlgMetadata
 
 useRegularization
 
 hMat
 

Static Public Attributes

 ConfigClass = ZogyImagePsfMatchConfig
 

Detailed Description

Task to perform Zogy PSF matching and image subtraction.

This class inherits from ImagePsfMatchTask to contain the _warper
subtask and related methods.

Definition at line 1269 of file zogy.py.

Constructor & Destructor Documentation

◆ __init__()

def lsst.ip.diffim.zogy.ZogyImagePsfMatchTask.__init__ (   self,
args,
**  kwargs 
)
Create the ImagePsfMatchTask.

Reimplemented from lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.

Definition at line 1278 of file zogy.py.

Member Function Documentation

◆ getFwhmPix()

def lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.getFwhmPix (   self,
  psf 
)
inherited
Return the FWHM in pixels of a Psf.

Definition at line 333 of file imagePsfMatch.py.

◆ getSelectSources()

def lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.getSelectSources (   self,
  exposure,
  sigma = None,
  doSmooth = True,
  idFactory = None 
)
inherited
Get sources to use for Psf-matching.

This method runs detection and measurement on an exposure.
The returned set of sources will be used as candidates for
Psf-matching.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure on which to run detection/measurement
sigma : `float`
    Detection threshold
doSmooth : `bool`
    Whether or not to smooth the Exposure with Psf before detection
idFactory :
    Factory for the generation of Source ids

Returns
-------
selectSources :
    source catalog containing candidates for the Psf-matching

Definition at line 757 of file imagePsfMatch.py.

◆ makeCandidateList()

def lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.makeCandidateList (   self,
  templateExposure,
  scienceExposure,
  kernelSize,
  candidateList = None 
)
inherited
Make a list of acceptable KernelCandidates.

Accept or generate a list of candidate sources for
Psf-matching, and examine the Mask planes in both of the
images for indications of bad pixels

Parameters
----------
templateExposure : `lsst.afw.image.Exposure`
    Exposure that will be convolved
scienceExposure : `lsst.afw.image.Exposure`
    Exposure that will be matched-to
kernelSize : `float`
    Dimensions of the Psf-matching Kernel, used to grow detection footprints
candidateList : `list`, optional
    List of Sources to examine. Elements must be of type afw.table.Source
    or a type that wraps a Source and has a getSource() method, such as
    meas.algorithms.PsfCandidateF.

Returns
-------
candidateList : `list` of `dict`
    A list of dicts having a "source" and "footprint"
    field for the Sources deemed to be appropriate for Psf
    matching

Definition at line 815 of file imagePsfMatch.py.

◆ matchExposures()

def lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.matchExposures (   self,
  templateExposure,
  scienceExposure,
  templateFwhmPix = None,
  scienceFwhmPix = None,
  candidateList = None,
  doWarping = True,
  convolveTemplate = True 
)
inherited
Warp and PSF-match an exposure to the reference.

Do the following, in order:

- Warp templateExposure to match scienceExposure,
    if doWarping True and their WCSs do not already match
- Determine a PSF matching kernel and differential background model
    that matches templateExposure to scienceExposure
- Convolve templateExposure by PSF matching kernel

Parameters
----------
templateExposure : `lsst.afw.image.Exposure`
    Exposure to warp and PSF-match to the reference masked image
scienceExposure : `lsst.afw.image.Exposure`
    Exposure whose WCS and PSF are to be matched to
templateFwhmPix :`float`
    FWHM (in pixels) of the Psf in the template image (image to convolve)
scienceFwhmPix : `float`
    FWHM (in pixels) of the Psf in the science image
candidateList : `list`, optional
    a list of footprints/maskedImages for kernel candidates;
    if `None` then source detection is run.

    - Currently supported: list of Footprints or measAlg.PsfCandidateF

doWarping : `bool`
    what to do if ``templateExposure`` and ``scienceExposure`` WCSs do not match:

    - if `True` then warp ``templateExposure`` to match ``scienceExposure``
    - if `False` then raise an Exception

convolveTemplate : `bool`
    Whether to convolve the template image or the science image:

    - if `True`, ``templateExposure`` is warped if doWarping,
      ``templateExposure`` is convolved
    - if `False`, ``templateExposure`` is warped if doWarping,
      ``scienceExposure`` is convolved

Returns
-------
results : `lsst.pipe.base.Struct`
    An `lsst.pipe.base.Struct` containing these fields:

    - ``matchedImage`` : the PSF-matched exposure =
        Warped ``templateExposure`` convolved by psfMatchingKernel. This has:

        - the same parent bbox, Wcs and PhotoCalib as scienceExposure
        - the same filter as templateExposure
        - no Psf (because the PSF-matching process does not compute one)

    - ``psfMatchingKernel`` : the PSF matching kernel
    - ``backgroundModel`` : differential background model
    - ``kernelCellSet`` : SpatialCellSet used to solve for the PSF matching kernel

Raises
------
RuntimeError
   Raised if doWarping is False and ``templateExposure`` and
   ``scienceExposure`` WCSs do not match

Definition at line 340 of file imagePsfMatch.py.

◆ matchMaskedImages()

def lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.matchMaskedImages (   self,
  templateMaskedImage,
  scienceMaskedImage,
  candidateList,
  templateFwhmPix = None,
  scienceFwhmPix = None 
)
inherited
PSF-match a MaskedImage (templateMaskedImage) to a reference MaskedImage (scienceMaskedImage).

Do the following, in order:

- Determine a PSF matching kernel and differential background model
    that matches templateMaskedImage to scienceMaskedImage
- Convolve templateMaskedImage by the PSF matching kernel

Parameters
----------
templateMaskedImage : `lsst.afw.image.MaskedImage`
    masked image to PSF-match to the reference masked image;
    must be warped to match the reference masked image
scienceMaskedImage : `lsst.afw.image.MaskedImage`
    maskedImage whose PSF is to be matched to
templateFwhmPix : `float`
    FWHM (in pixels) of the Psf in the template image (image to convolve)
scienceFwhmPix : `float`
    FWHM (in pixels) of the Psf in the science image
candidateList : `list`, optional
    A list of footprints/maskedImages for kernel candidates;
    if `None` then source detection is run.

    - Currently supported: list of Footprints or measAlg.PsfCandidateF

Returns
-------
result : `callable`
An `lsst.pipe.base.Struct` containing these fields:

- psfMatchedMaskedImage: the PSF-matched masked image =
    ``templateMaskedImage`` convolved with psfMatchingKernel.
    This has the same xy0, dimensions and wcs as ``scienceMaskedImage``.
- psfMatchingKernel: the PSF matching kernel
- backgroundModel: differential background model
- kernelCellSet: SpatialCellSet used to solve for the PSF matching kernel

Raises
------
RuntimeError
    Raised if input images have different dimensions

Definition at line 458 of file imagePsfMatch.py.

◆ run()

def lsst.ip.diffim.zogy.ZogyImagePsfMatchTask.run (   self,
  scienceExposure,
  templateExposure,
  doWarping = True 
)
Register, PSF-match, and subtract two Exposures, ``scienceExposure - templateExposure``
using the ZOGY algorithm.

Parameters
----------
templateExposure : `lsst.afw.image.Exposure`
    exposure to be warped to scienceExposure.
scienceExposure : `lsst.afw.image.Exposure`
    reference Exposure.
doWarping : `bool`
    what to do if templateExposure's and scienceExposure's WCSs do not match:
    - if True then warp templateExposure to match scienceExposure
    - if False then raise an Exception

Notes
-----
Do the following, in order:
    - Warp templateExposure to match scienceExposure, if their WCSs do not already match
    - Compute subtracted exposure ZOGY image subtraction algorithm on the two exposures

This is the new entry point of the task as of DM-25115.

Returns
-------
results : `lsst.pipe.base.Struct` containing these fields:
    - subtractedExposure: `lsst.afw.image.Exposure`
        The subtraction result.
    - warpedExposure: `lsst.afw.image.Exposure` or `None`
        templateExposure after warping to match scienceExposure

Definition at line 1281 of file zogy.py.

◆ subtractExposures() [1/2]

def lsst.ip.diffim.zogy.ZogyImagePsfMatchTask.subtractExposures (   self,
  templateExposure,
  scienceExposure,
args 
)

Definition at line 1331 of file zogy.py.

◆ subtractExposures() [2/2]

def lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.subtractExposures (   self,
  templateExposure,
  scienceExposure,
  templateFwhmPix = None,
  scienceFwhmPix = None,
  candidateList = None,
  doWarping = True,
  convolveTemplate = True 
)
inherited
Register, Psf-match and subtract two Exposures.

Do the following, in order:

- Warp templateExposure to match scienceExposure, if their WCSs do not already match
- Determine a PSF matching kernel and differential background model
    that matches templateExposure to scienceExposure
- PSF-match templateExposure to scienceExposure
- Compute subtracted exposure (see return values for equation).

Parameters
----------
templateExposure : `lsst.afw.image.Exposure`
    Exposure to PSF-match to scienceExposure
scienceExposure : `lsst.afw.image.Exposure`
    Reference Exposure
templateFwhmPix : `float`
    FWHM (in pixels) of the Psf in the template image (image to convolve)
scienceFwhmPix : `float`
    FWHM (in pixels) of the Psf in the science image
candidateList : `list`, optional
    A list of footprints/maskedImages for kernel candidates;
    if `None` then source detection is run.

    - Currently supported: list of Footprints or measAlg.PsfCandidateF

doWarping : `bool`
    What to do if ``templateExposure``` and ``scienceExposure`` WCSs do
    not match:

    - if `True` then warp ``templateExposure`` to match ``scienceExposure``
    - if `False` then raise an Exception

convolveTemplate : `bool`
    Convolve the template image or the science image

    - if `True`, ``templateExposure`` is warped if doWarping,
      ``templateExposure`` is convolved
    - if `False`, ``templateExposure`` is warped if doWarping,
      ``scienceExposure is`` convolved

Returns
-------
result : `lsst.pipe.base.Struct`
    An `lsst.pipe.base.Struct` containing these fields:

    - ``subtractedExposure`` : subtracted Exposure
        scienceExposure - (matchedImage + backgroundModel)
    - ``matchedImage`` : ``templateExposure`` after warping to match
                         ``templateExposure`` (if doWarping true),
                         and convolving with psfMatchingKernel
    - ``psfMatchingKernel`` : PSF matching kernel
    - ``backgroundModel`` : differential background model
    - ``kernelCellSet`` : SpatialCellSet used to determine PSF matching kernel

Definition at line 571 of file imagePsfMatch.py.

◆ subtractMaskedImages() [1/2]

def lsst.ip.diffim.zogy.ZogyImagePsfMatchTask.subtractMaskedImages (   self,
  templateExposure,
  scienceExposure,
args 
)

Definition at line 1334 of file zogy.py.

◆ subtractMaskedImages() [2/2]

def lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.subtractMaskedImages (   self,
  templateMaskedImage,
  scienceMaskedImage,
  candidateList,
  templateFwhmPix = None,
  scienceFwhmPix = None 
)
inherited
Psf-match and subtract two MaskedImages.

Do the following, in order:

- PSF-match templateMaskedImage to scienceMaskedImage
- Determine the differential background
- Return the difference: scienceMaskedImage
    ((warped templateMaskedImage convolved with psfMatchingKernel) + backgroundModel)

Parameters
----------
templateMaskedImage : `lsst.afw.image.MaskedImage`
    MaskedImage to PSF-match to ``scienceMaskedImage``
scienceMaskedImage : `lsst.afw.image.MaskedImage`
    Reference MaskedImage
templateFwhmPix : `float`
    FWHM (in pixels) of the Psf in the template image (image to convolve)
scienceFwhmPix : `float`
    FWHM (in pixels) of the Psf in the science image
candidateList : `list`, optional
    A list of footprints/maskedImages for kernel candidates;
    if `None` then source detection is run.

    - Currently supported: list of Footprints or measAlg.PsfCandidateF

Returns
-------
results : `lsst.pipe.base.Struct`
    An `lsst.pipe.base.Struct` containing these fields:

    - ``subtractedMaskedImage`` : ``scienceMaskedImage`` - (matchedImage + backgroundModel)
    - ``matchedImage`` : templateMaskedImage convolved with psfMatchingKernel
    - `psfMatchingKernel`` : PSF matching kernel
    - ``backgroundModel`` : differential background model
    - ``kernelCellSet`` : SpatialCellSet used to determine PSF matching kernel

Definition at line 687 of file imagePsfMatch.py.

Member Data Documentation

◆ background

lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.background
inherited

Definition at line 326 of file imagePsfMatch.py.

◆ ConfigClass

lsst.ip.diffim.zogy.ZogyImagePsfMatchTask.ConfigClass = ZogyImagePsfMatchConfig
static

Definition at line 1276 of file zogy.py.

◆ hMat

lsst.ip.diffim.psfMatch.PsfMatchTask.hMat
inherited

Definition at line 660 of file psfMatch.py.

◆ kConfig

lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.kConfig
inherited

Definition at line 322 of file imagePsfMatch.py.

◆ selectAlgMetadata

lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.selectAlgMetadata
inherited

Definition at line 329 of file imagePsfMatch.py.

◆ selectSchema

lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.selectSchema
inherited

Definition at line 328 of file imagePsfMatch.py.

◆ useRegularization

lsst.ip.diffim.psfMatch.PsfMatchTask.useRegularization
inherited

Definition at line 655 of file psfMatch.py.


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