33from lsst.meas.algorithms
import SourceDetectionTask, SubtractBackgroundTask, WarpedPsf
35from .makeKernelBasisList
import makeKernelBasisList
36from .psfMatch
import PsfMatchTask, PsfMatchConfigDF, PsfMatchConfigAL
37from .
import utils
as diffimUtils
38from .
import diffimLib
39from .
import diffimTools
41from lsst.utils.timer
import timeMethod
43__all__ = [
"ImagePsfMatchConfig",
"ImagePsfMatchTask",
"subtractAlgorithmRegistry"]
45sigma2fwhm = 2.*np.sqrt(2.*np.log(2.))
49 """Configuration for image-to-image Psf matching.
51 kernel = pexConfig.ConfigChoiceField(
59 selectDetection = pexConfig.ConfigurableField(
60 target=SourceDetectionTask,
61 doc=
"Initial detections used to feed stars to kernel fitting",
63 selectMeasurement = pexConfig.ConfigurableField(
64 target=SingleFrameMeasurementTask,
65 doc=
"Initial measurements used to feed stars to kernel fitting",
75 self.
selectMeasurement.algorithms.names = (
'base_SdssCentroid',
'base_PsfFlux',
'base_PixelFlags',
76 'base_SdssShape',
'base_GaussianFlux',
'base_SkyCoord')
83 """Psf-match two MaskedImages or Exposures using the sources in the images.
88 Arguments to be passed to lsst.ip.diffim.PsfMatchTask.__init__
90 Keyword arguments to be passed to lsst.ip.diffim.PsfMatchTask.__init__
94 ConfigClass = ImagePsfMatchConfig
97 """Create the ImagePsfMatchTask.
99 PsfMatchTask.__init__(self, *args, **kwargs)
108 self.makeSubtask(
"selectDetection", schema=self.
selectSchema)
113 templateFwhmPix=None, scienceFwhmPix=None,
114 candidateList=None, doWarping=True, convolveTemplate=True):
115 """Warp and PSF-match an exposure to the reference.
117 Do the following, in order:
119 - Warp templateExposure to match scienceExposure,
120 if doWarping
True and their WCSs do
not already match
121 - Determine a PSF matching kernel
and differential background model
122 that matches templateExposure to scienceExposure
123 - Convolve templateExposure by PSF matching kernel
128 Exposure to warp
and PSF-match to the reference masked image
130 Exposure whose WCS
and PSF are to be matched to
131 templateFwhmPix :`float`
132 FWHM (
in pixels) of the Psf
in the template image (image to convolve)
133 scienceFwhmPix : `float`
134 FWHM (
in pixels) of the Psf
in the science image
135 candidateList : `list`, optional
136 a list of footprints/maskedImages
for kernel candidates;
137 if `
None` then source detection
is run.
139 - Currently supported: list of Footprints
or measAlg.PsfCandidateF
142 what to do
if ``templateExposure``
and ``scienceExposure`` WCSs do
not match:
144 -
if `
True` then warp ``templateExposure`` to match ``scienceExposure``
145 -
if `
False` then
raise an Exception
147 convolveTemplate : `bool`
148 Whether to convolve the template image
or the science image:
150 -
if `
True`, ``templateExposure``
is warped
if doWarping,
151 ``templateExposure``
is convolved
152 -
if `
False`, ``templateExposure``
is warped
if doWarping,
153 ``scienceExposure``
is convolved
157 results : `lsst.pipe.base.Struct`
158 An `lsst.pipe.base.Struct` containing these fields:
160 - ``matchedImage`` : the PSF-matched exposure =
161 Warped ``templateExposure`` convolved by psfMatchingKernel. This has:
163 - the same parent bbox, Wcs
and PhotoCalib
as scienceExposure
164 - the same filter
as templateExposure
165 - no Psf (because the PSF-matching process does
not compute one)
167 - ``psfMatchingKernel`` : the PSF matching kernel
168 - ``backgroundModel`` : differential background model
169 - ``kernelCellSet`` : SpatialCellSet used to solve
for the PSF matching kernel
174 Raised
if doWarping
is False and ``templateExposure``
and
175 ``scienceExposure`` WCSs do
not match
177 if not self.
_validateWcs(templateExposure, scienceExposure):
179 self.log.info(
"Astrometrically registering template to science image")
180 templatePsf = templateExposure.getPsf()
183 scienceExposure.getWcs())
184 psfWarped = WarpedPsf(templatePsf, xyTransform)
185 templateExposure = self.
_warper.warpExposure(scienceExposure.getWcs(),
187 destBBox=scienceExposure.getBBox())
188 templateExposure.setPsf(psfWarped)
190 self.log.error(
"ERROR: Input images not registered")
191 raise RuntimeError(
"Input images not registered")
193 if templateFwhmPix
is None:
194 if not templateExposure.hasPsf():
195 self.log.warning(
"No estimate of Psf FWHM for template image")
197 templateFwhmPix = diffimUtils.getPsfFwhm(templateExposure.psf)
198 self.log.info(
"templateFwhmPix: %s", templateFwhmPix)
200 if scienceFwhmPix
is None:
201 if not scienceExposure.hasPsf():
202 self.log.warning(
"No estimate of Psf FWHM for science image")
204 scienceFwhmPix = diffimUtils.getPsfFwhm(scienceExposure.psf)
205 self.log.info(
"scienceFwhmPix: %s", scienceFwhmPix)
210 templateExposure, scienceExposure, kernelSize, candidateList)
212 templateExposure.getMaskedImage(), scienceExposure.getMaskedImage(), candidateList,
213 templateFwhmPix=templateFwhmPix, scienceFwhmPix=scienceFwhmPix)
217 templateExposure, scienceExposure, kernelSize, candidateList)
219 scienceExposure.getMaskedImage(), templateExposure.getMaskedImage(), candidateList,
220 templateFwhmPix=scienceFwhmPix, scienceFwhmPix=templateFwhmPix)
223 psfMatchedExposure.setFilter(templateExposure.getFilter())
224 psfMatchedExposure.setPhotoCalib(scienceExposure.getPhotoCalib())
225 results.warpedExposure = templateExposure
226 results.matchedExposure = psfMatchedExposure
231 templateFwhmPix=None, scienceFwhmPix=None):
232 """PSF-match a MaskedImage (templateMaskedImage) to a reference MaskedImage (scienceMaskedImage).
234 Do the following, in order:
236 - Determine a PSF matching kernel
and differential background model
237 that matches templateMaskedImage to scienceMaskedImage
238 - Convolve templateMaskedImage by the PSF matching kernel
243 masked image to PSF-match to the reference masked image;
244 must be warped to match the reference masked image
246 maskedImage whose PSF
is to be matched to
247 templateFwhmPix : `float`
248 FWHM (
in pixels) of the Psf
in the template image (image to convolve)
249 scienceFwhmPix : `float`
250 FWHM (
in pixels) of the Psf
in the science image
251 candidateList : `list`, optional
252 A list of footprints/maskedImages
for kernel candidates;
253 if `
None` then source detection
is run.
255 - Currently supported: list of Footprints
or measAlg.PsfCandidateF
260 An `lsst.pipe.base.Struct` containing these fields:
262 - psfMatchedMaskedImage: the PSF-matched masked image =
263 ``templateMaskedImage`` convolved
with psfMatchingKernel.
264 This has the same xy0, dimensions
and wcs
as ``scienceMaskedImage``.
265 - psfMatchingKernel: the PSF matching kernel
266 - backgroundModel: differential background model
267 - kernelCellSet: SpatialCellSet used to solve
for the PSF matching kernel
272 Raised
if input images have different dimensions
278 displaySpatialCells =
lsstDebug.Info(__name__).displaySpatialCells
280 if not maskTransparency:
283 afwDisplay.setDefaultMaskTransparency(maskTransparency)
285 if not candidateList:
286 raise RuntimeError(
"Candidate list must be populated by makeCandidateList")
288 if not self.
_validateSize(templateMaskedImage, scienceMaskedImage):
289 self.log.error(
"ERROR: Input images different size")
290 raise RuntimeError(
"Input images different size")
292 if display
and displayTemplate:
293 disp = afwDisplay.Display(frame=lsstDebug.frame)
294 disp.mtv(templateMaskedImage, title=
"Image to convolve")
297 if display
and displaySciIm:
298 disp = afwDisplay.Display(frame=lsstDebug.frame)
299 disp.mtv(scienceMaskedImage, title=
"Image to not convolve")
306 if display
and displaySpatialCells:
307 diffimUtils.showKernelSpatialCells(scienceMaskedImage, kernelCellSet,
308 symb=
"o", ctype=afwDisplay.CYAN, ctypeUnused=afwDisplay.YELLOW,
309 ctypeBad=afwDisplay.RED, size=4, frame=lsstDebug.frame,
310 title=
"Image to not convolve")
313 if templateFwhmPix
and scienceFwhmPix:
314 self.log.info(
"Matching Psf FWHM %.2f -> %.2f pix", templateFwhmPix, scienceFwhmPix)
321 bicDegrees = nbe(tmpKernelCellSet, self.log)
323 basisDegGauss=bicDegrees[0], metadata=self.metadata)
327 metadata=self.metadata)
329 spatialSolution, psfMatchingKernel, backgroundModel = self.
_solve(kernelCellSet, basisList)
331 psfMatchedMaskedImage = afwImage.MaskedImageF(templateMaskedImage.getBBox())
333 convolutionControl.setDoNormalize(
False)
334 afwMath.convolve(psfMatchedMaskedImage, templateMaskedImage, psfMatchingKernel, convolutionControl)
335 return pipeBase.Struct(
336 matchedImage=psfMatchedMaskedImage,
337 psfMatchingKernel=psfMatchingKernel,
338 backgroundModel=backgroundModel,
339 kernelCellSet=kernelCellSet,
344 templateFwhmPix=None, scienceFwhmPix=None,
345 candidateList=None, doWarping=True, convolveTemplate=True):
346 """Register, Psf-match and subtract two Exposures.
348 Do the following, in order:
350 - Warp templateExposure to match scienceExposure,
if their WCSs do
not already match
351 - Determine a PSF matching kernel
and differential background model
352 that matches templateExposure to scienceExposure
353 - PSF-match templateExposure to scienceExposure
354 - Compute subtracted exposure (see
return values
for equation).
358 templateExposure : `lsst.afw.image.ExposureF`
359 Exposure to PSF-match to scienceExposure
360 scienceExposure : `lsst.afw.image.ExposureF`
362 templateFwhmPix : `float`
363 FWHM (
in pixels) of the Psf
in the template image (image to convolve)
364 scienceFwhmPix : `float`
365 FWHM (
in pixels) of the Psf
in the science image
366 candidateList : `list`, optional
367 A list of footprints/maskedImages
for kernel candidates;
368 if `
None` then source detection
is run.
370 - Currently supported: list of Footprints
or measAlg.PsfCandidateF
373 What to do
if ``templateExposure```
and ``scienceExposure`` WCSs do
376 -
if `
True` then warp ``templateExposure`` to match ``scienceExposure``
377 -
if `
False` then
raise an Exception
379 convolveTemplate : `bool`
380 Convolve the template image
or the science image
382 -
if `
True`, ``templateExposure``
is warped
if doWarping,
383 ``templateExposure``
is convolved
384 -
if `
False`, ``templateExposure``
is warped
if doWarping,
385 ``scienceExposure
is`` convolved
389 result : `lsst.pipe.base.Struct`
390 An `lsst.pipe.base.Struct` containing these fields:
392 - ``subtractedExposure`` : subtracted Exposure
393 scienceExposure - (matchedImage + backgroundModel)
394 - ``matchedImage`` : ``templateExposure`` after warping to match
395 ``templateExposure`` (
if doWarping true),
396 and convolving
with psfMatchingKernel
397 - ``psfMatchingKernel`` : PSF matching kernel
398 - ``backgroundModel`` : differential background model
399 - ``kernelCellSet`` : SpatialCellSet used to determine PSF matching kernel
402 templateExposure=templateExposure,
403 scienceExposure=scienceExposure,
404 templateFwhmPix=templateFwhmPix,
405 scienceFwhmPix=scienceFwhmPix,
406 candidateList=candidateList,
408 convolveTemplate=convolveTemplate
411 subtractedExposure = afwImage.ExposureF(scienceExposure, deep=
True)
417 subtractedMaskedImage = subtractedExposure.maskedImage
418 subtractedMaskedImage -= results.matchedExposure.maskedImage
419 subtractedMaskedImage -= results.backgroundModel
421 subtractedMaskedImage = subtractedExposure.maskedImage
422 subtractedMaskedImage[:, :] = results.warpedExposure.maskedImage
423 subtractedMaskedImage -= results.matchedExposure.maskedImage
424 subtractedMaskedImage -= results.backgroundModel
427 subtractedMaskedImage *= -1
430 subtractedMaskedImage /= results.psfMatchingKernel.computeImage(
431 afwImage.ImageD(results.psfMatchingKernel.getDimensions()),
False)
433 subtractedExposure.setPsf(results.warpedExposure.getPsf())
439 if not maskTransparency:
442 afwDisplay.setDefaultMaskTransparency(maskTransparency)
443 if display
and displayDiffIm:
444 disp = afwDisplay.Display(frame=lsstDebug.frame)
445 disp.mtv(templateExposure, title=
"Template")
447 disp = afwDisplay.Display(frame=lsstDebug.frame)
448 disp.mtv(results.matchedExposure, title=
"Matched template")
450 disp = afwDisplay.Display(frame=lsstDebug.frame)
451 disp.mtv(scienceExposure, title=
"Science Image")
453 disp = afwDisplay.Display(frame=lsstDebug.frame)
454 disp.mtv(subtractedExposure, title=
"Difference Image")
457 results.subtractedExposure = subtractedExposure
462 templateFwhmPix=None, scienceFwhmPix=None):
463 """Psf-match and subtract two MaskedImages.
465 Do the following, in order:
467 - PSF-match templateMaskedImage to scienceMaskedImage
468 - Determine the differential background
469 - Return the difference: scienceMaskedImage
470 ((warped templateMaskedImage convolved
with psfMatchingKernel) + backgroundModel)
475 MaskedImage to PSF-match to ``scienceMaskedImage``
477 Reference MaskedImage
478 templateFwhmPix : `float`
479 FWHM (
in pixels) of the Psf
in the template image (image to convolve)
480 scienceFwhmPix : `float`
481 FWHM (
in pixels) of the Psf
in the science image
482 candidateList : `list`, optional
483 A list of footprints/maskedImages
for kernel candidates;
484 if `
None` then source detection
is run.
486 - Currently supported: list of Footprints
or measAlg.PsfCandidateF
490 results : `lsst.pipe.base.Struct`
491 An `lsst.pipe.base.Struct` containing these fields:
493 - ``subtractedMaskedImage`` : ``scienceMaskedImage`` - (matchedImage + backgroundModel)
494 - ``matchedImage`` : templateMaskedImage convolved
with psfMatchingKernel
495 - `psfMatchingKernel`` : PSF matching kernel
496 - ``backgroundModel`` : differential background model
497 - ``kernelCellSet`` : SpatialCellSet used to determine PSF matching kernel
500 if not candidateList:
501 raise RuntimeError(
"Candidate list must be populated by makeCandidateList")
504 templateMaskedImage=templateMaskedImage,
505 scienceMaskedImage=scienceMaskedImage,
506 candidateList=candidateList,
507 templateFwhmPix=templateFwhmPix,
508 scienceFwhmPix=scienceFwhmPix,
511 subtractedMaskedImage = afwImage.MaskedImageF(scienceMaskedImage,
True)
512 subtractedMaskedImage -= results.matchedImage
513 subtractedMaskedImage -= results.backgroundModel
514 results.subtractedMaskedImage = subtractedMaskedImage
520 if not maskTransparency:
523 afwDisplay.setDefaultMaskTransparency(maskTransparency)
524 if display
and displayDiffIm:
525 disp = afwDisplay.Display(frame=lsstDebug.frame)
526 disp.mtv(subtractedMaskedImage, title=
"Subtracted masked image")
532 """Get sources to use for Psf-matching.
534 This method runs detection and measurement on an exposure.
535 The returned set of sources will be used
as candidates
for
541 Exposure on which to run detection/measurement
545 Whether
or not to smooth the Exposure
with Psf before detection
547 Factory
for the generation of Source ids
552 source catalog containing candidates
for the Psf-matching
555 table = afwTable.SourceTable.make(self.
selectSchema, idFactory)
558 mi = exposure.getMaskedImage()
560 imArr = mi.getImage().getArray()
561 maskArr = mi.getMask().getArray()
562 miArr = np.ma.masked_array(imArr, mask=maskArr)
565 bkgd = fitBg.getImageF(self.
background.config.algorithm,
568 self.log.warning(
"Failed to get background model. Falling back to median background estimation")
569 bkgd = np.ma.median(miArr)
575 detRet = self.selectDetection.
run(
581 selectSources = detRet.sources
582 self.selectMeasurement.
run(measCat=selectSources, exposure=exposure)
590 """Make a list of acceptable KernelCandidates.
592 Accept or generate a list of candidate sources
for
593 Psf-matching,
and examine the Mask planes
in both of the
594 images
for indications of bad pixels
599 Exposure that will be convolved
601 Exposure that will be matched-to
603 Dimensions of the Psf-matching Kernel, used to grow detection footprints
604 candidateList : `list`, optional
605 List of Sources to examine. Elements must be of type afw.table.Source
606 or a type that wraps a Source
and has a getSource() method, such
as
607 meas.algorithms.PsfCandidateF.
611 candidateList : `list` of `dict`
612 A list of dicts having a
"source" and "footprint"
613 field
for the Sources deemed to be appropriate
for Psf
616 if candidateList
is None:
619 if len(candidateList) < 1:
620 raise RuntimeError(
"No candidates in candidateList")
622 listTypes = set(type(x)
for x
in candidateList)
623 if len(listTypes) > 1:
624 raise RuntimeError(
"Candidate list contains mixed types: %s" % [t
for t
in listTypes])
626 if not isinstance(candidateList[0], afwTable.SourceRecord):
628 candidateList[0].getSource()
629 except Exception
as e:
630 raise RuntimeError(f
"Candidate List is of type: {type(candidateList[0])} "
631 "Can only make candidate list from list of afwTable.SourceRecords, "
632 f
"measAlg.PsfCandidateF or other type with a getSource() method: {e}")
633 candidateList = [c.getSource()
for c
in candidateList]
635 candidateList = diffimTools.sourceToFootprintList(candidateList,
636 templateExposure, scienceExposure,
640 if len(candidateList) == 0:
641 raise RuntimeError(
"Cannot find any objects suitable for KernelCandidacy")
645 def makeKernelBasisList(self, targetFwhmPix=None, referenceFwhmPix=None,
646 basisDegGauss=None, basisSigmaGauss=None, metadata=None):
647 """Wrapper to set log messages for
652 targetFwhmPix : `float`, optional
653 Passed on to `lsst.ip.diffim.generateAlardLuptonBasisList`.
654 Not used for delta function basis sets.
655 referenceFwhmPix : `float`, optional
656 Passed on to `lsst.ip.diffim.generateAlardLuptonBasisList`.
657 Not used
for delta function basis sets.
658 basisDegGauss : `list` of `int`, optional
659 Passed on to `lsst.ip.diffim.generateAlardLuptonBasisList`.
660 Not used
for delta function basis sets.
661 basisSigmaGauss : `list` of `int`, optional
662 Passed on to `lsst.ip.diffim.generateAlardLuptonBasisList`.
663 Not used
for delta function basis sets.
665 Passed on to `lsst.ip.diffim.generateAlardLuptonBasisList`.
666 Not used
for delta function basis sets.
670 basisList: `list` of `lsst.afw.math.kernel.FixedKernel`
671 List of basis kernels.
674 targetFwhmPix=targetFwhmPix,
675 referenceFwhmPix=referenceFwhmPix,
676 basisDegGauss=basisDegGauss,
677 basisSigmaGauss=basisSigmaGauss,
679 if targetFwhmPix == referenceFwhmPix:
680 self.log.info(
"Target and reference psf fwhms are equal, falling back to config values")
681 elif referenceFwhmPix > targetFwhmPix:
682 self.log.info(
"Reference psf fwhm is the greater, normal convolution mode")
684 self.log.info(
"Target psf fwhm is the greater, deconvolution mode")
688 def _adaptCellSize(self, candidateList):
689 """NOT IMPLEMENTED YET.
693 def _buildCellSet(self, templateMaskedImage, scienceMaskedImage, candidateList):
694 """Build a SpatialCellSet for use with the solve method.
699 MaskedImage to PSF-matched to scienceMaskedImage
701 Reference MaskedImage
702 candidateList : `list`
703 A list of footprints/maskedImages for kernel candidates;
705 - Currently supported: list of Footprints
or measAlg.PsfCandidateF
710 a SpatialCellSet
for use
with self.
_solve
712 if not candidateList:
713 raise RuntimeError(
"Candidate list must be populated by makeCandidateList")
719 sizeCellX, sizeCellY)
723 for cand
in candidateList:
725 bbox = cand.getBBox()
727 bbox = cand[
'footprint'].getBBox()
728 tmi = afwImage.MaskedImageF(templateMaskedImage, bbox)
729 smi = afwImage.MaskedImageF(scienceMaskedImage, bbox)
733 cand = cand[
'source']
734 xPos = cand.getCentroid()[0]
735 yPos = cand.getCentroid()[1]
736 cand = diffimLib.makeKernelCandidate(xPos, yPos, tmi, smi, ps)
738 self.log.debug(
"Candidate %d at %f, %f", cand.getId(), cand.getXCenter(), cand.getYCenter())
739 kernelCellSet.insertCandidate(cand)
743 def _validateSize(self, templateMaskedImage, scienceMaskedImage):
744 """Return True if two image-like objects are the same size.
746 return templateMaskedImage.getDimensions() == scienceMaskedImage.getDimensions()
748 def _validateWcs(self, templateExposure, scienceExposure):
749 """Return True if the WCS of the two Exposures have the same origin and extent.
751 templateWcs = templateExposure.getWcs()
752 scienceWcs = scienceExposure.getWcs()
753 templateBBox = templateExposure.getBBox()
754 scienceBBox = scienceExposure.getBBox()
757 templateOrigin = templateWcs.pixelToSky(
geom.Point2D(templateBBox.getBegin()))
758 scienceOrigin = scienceWcs.pixelToSky(
geom.Point2D(scienceBBox.getBegin()))
761 templateLimit = templateWcs.pixelToSky(
geom.Point2D(templateBBox.getEnd()))
762 scienceLimit = scienceWcs.pixelToSky(
geom.Point2D(scienceBBox.getEnd()))
764 self.log.info(
"Template Wcs : %f,%f -> %f,%f",
765 templateOrigin[0], templateOrigin[1],
766 templateLimit[0], templateLimit[1])
767 self.log.info(
"Science Wcs : %f,%f -> %f,%f",
768 scienceOrigin[0], scienceOrigin[1],
769 scienceLimit[0], scienceLimit[1])
771 templateBBox =
geom.Box2D(templateOrigin.getPosition(geom.degrees),
772 templateLimit.getPosition(geom.degrees))
773 scienceBBox =
geom.Box2D(scienceOrigin.getPosition(geom.degrees),
774 scienceLimit.getPosition(geom.degrees))
775 if not (templateBBox.overlaps(scienceBBox)):
776 raise RuntimeError(
"Input images do not overlap at all")
778 if ((templateOrigin != scienceOrigin)
779 or (templateLimit != scienceLimit)
780 or (templateExposure.getDimensions() != scienceExposure.getDimensions())):
785subtractAlgorithmRegistry = pexConfig.makeRegistry(
786 doc=
"A registry of subtraction algorithms for use as a subtask in imageDifference",
789subtractAlgorithmRegistry.register(
'al', ImagePsfMatchTask)
def _validateWcs(self, templateExposure, scienceExposure)
def _adaptCellSize(self, candidateList)
def _buildCellSet(self, templateMaskedImage, scienceMaskedImage, candidateList)
def _validateSize(self, templateMaskedImage, scienceMaskedImage)
def subtractMaskedImages(self, templateMaskedImage, scienceMaskedImage, candidateList, templateFwhmPix=None, scienceFwhmPix=None)
def matchMaskedImages(self, templateMaskedImage, scienceMaskedImage, candidateList, templateFwhmPix=None, scienceFwhmPix=None)
def __init__(self, *args, **kwargs)
def getSelectSources(self, exposure, sigma=None, doSmooth=True, idFactory=None)
def subtractExposures(self, templateExposure, scienceExposure, templateFwhmPix=None, scienceFwhmPix=None, candidateList=None, doWarping=True, convolveTemplate=True)
def matchExposures(self, templateExposure, scienceExposure, templateFwhmPix=None, scienceFwhmPix=None, candidateList=None, doWarping=True, convolveTemplate=True)
def makeKernelBasisList(self, targetFwhmPix=None, referenceFwhmPix=None, basisDegGauss=None, basisSigmaGauss=None, metadata=None)
def makeCandidateList(self, templateExposure, scienceExposure, kernelSize, candidateList=None)
def _buildCellSet(self, *args)
def _solve(self, kernelCellSet, basisList, returnOnExcept=False)
std::shared_ptr< TransformPoint2ToPoint2 > makeWcsPairTransform(SkyWcs const &src, SkyWcs const &dst)
std::shared_ptr< Exposure< ImagePixelT, MaskPixelT, VariancePixelT > > makeExposure(MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > &mimage, std::shared_ptr< geom::SkyWcs const > wcs=std::shared_ptr< geom::SkyWcs const >())
void convolve(OutImageT &convolvedImage, InImageT const &inImage, KernelT const &kernel, ConvolutionControl const &convolutionControl=ConvolutionControl())
def run(self, coaddExposures, bbox, wcs, dataIds, physical_filter=None, **kwargs)