|
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) |
|
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 1098 of file zogy.py.
◆ __init__()
def lsst.ip.diffim.zogy.ZogyImagePsfMatchTask.__init__ |
( |
|
self, |
|
|
* |
args, |
|
|
** |
kwargs |
|
) |
| |
◆ getFwhmPix()
def lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.getFwhmPix |
( |
|
self, |
|
|
|
psf |
|
) |
| |
|
inherited |
◆ 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 752 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 810 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.
◆ subtractExposures() [1/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 1125 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 570 of file imagePsfMatch.py.
◆ subtractMaskedImages() [1/2]
def lsst.ip.diffim.zogy.ZogyImagePsfMatchTask.subtractMaskedImages |
( |
|
self, |
|
|
|
templateExposure, |
|
|
|
scienceExposure, |
|
|
|
doWarping = True , |
|
|
|
spatiallyVarying = True , |
|
|
|
inImageSpace = False , |
|
|
|
doPreConvolve = False |
|
) |
| |
◆ 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 682 of file imagePsfMatch.py.
◆ background
lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.background |
|
inherited |
◆ ConfigClass
◆ hMat
lsst.ip.diffim.psfMatch.PsfMatchTask.hMat |
|
inherited |
◆ kConfig
lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.kConfig |
|
inherited |
◆ selectAlgMetadata
lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.selectAlgMetadata |
|
inherited |
◆ selectSchema
lsst.ip.diffim.imagePsfMatch.ImagePsfMatchTask.selectSchema |
|
inherited |
◆ useRegularization
lsst.ip.diffim.psfMatch.PsfMatchTask.useRegularization |
|
inherited |
The documentation for this class was generated from the following file: