lsst.ip.diffim  17.0-1-g99531fe
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 subtractExposures (self, templateExposure, scienceExposure, doWarping=True, spatiallyVarying=True, inImageSpace=False, doPreConvolve=False)
 
def subtractMaskedImages (self, templateExposure, scienceExposure, doWarping=True, spatiallyVarying=True, inImageSpace=False, doPreConvolve=False)
 
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 1070 of file zogy.py.

Constructor & Destructor Documentation

◆ __init__()

def lsst.ip.diffim.zogy.ZogyImagePsfMatchTask.__init__ (   self,
  args,
  kwargs 
)

Definition at line 1079 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 330 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 729 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 786 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's and scienceExposure's 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
-------
results : `Struct`
    a `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 Calib 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
if doWarping is False and templateExposure's and scienceExposure's
WCSs do not match

Definition at line 338 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`
a `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
    if input images have different dimensions

Definition at line 446 of file imagePsfMatch.py.

◆ subtractExposures() [1/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's and scienceExposure's 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: `Struct`
    a `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 557 of file imagePsfMatch.py.

◆ subtractExposures() [2/2]

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

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

Parameters
----------
templateExposure : `lsst.afw.image.Exposure`
    exposure to PSF-match to scienceExposure. The exposure's mean value is subtracted
    in-place.
scienceExposure : `lsst.afw.image.Exposure`
    reference Exposure. The exposure's mean value is subtracted in-place.
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
spatiallyVarying : `bool`
    If True, perform the operation over a grid of patches across the two exposures
inImageSpace : `bool`
    If True, perform the Zogy convolutions in image space rather than in frequency space.
doPreConvolve : `bool`
    ***Currently not implemented.*** If True assume we are to compute the match filter-convolved
    exposure which can be thresholded for detection. In the case of Zogy this would mean
    we compute the Scorr image.

Returns
-------
A `lsst.pipe.base.Struct` containing these fields:
- subtractedExposure: subtracted Exposure
- warpedExposure: templateExposure after warping to match scienceExposure (if doWarping true)

Definition at line 1099 of file zogy.py.

◆ subtractMaskedImages() [1/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 : `Struct`
    a `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 661 of file imagePsfMatch.py.

◆ subtractMaskedImages() [2/2]

def lsst.ip.diffim.zogy.ZogyImagePsfMatchTask.subtractMaskedImages (   self,
  templateExposure,
  scienceExposure,
  doWarping = True,
  spatiallyVarying = True,
  inImageSpace = False,
  doPreConvolve = False 
)

Definition at line 1209 of file zogy.py.

Member Data Documentation

◆ background

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

Definition at line 323 of file imagePsfMatch.py.

◆ ConfigClass

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

Definition at line 1077 of file zogy.py.

◆ hMat

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

Definition at line 655 of file psfMatch.py.

◆ kConfig

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

Definition at line 319 of file imagePsfMatch.py.

◆ selectAlgMetadata

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

Definition at line 326 of file imagePsfMatch.py.

◆ selectSchema

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

Definition at line 325 of file imagePsfMatch.py.

◆ useRegularization

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

Definition at line 650 of file psfMatch.py.


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