Classes | |
| class | GetDcrTemplateConnections |
| class | GetTemplateConnections |
Functions | |
| run (self, *, coaddExposureHandles, bbox, wcs, dataIds, physical_filter) | |
| checkHighVariance (self, template) | |
| _makeExposureCatalog (self, exposureRefs, dataIds) | |
| _merge (self, maskedImages, bbox, wcs) | |
| _makePsf (self, template, catalog, wcs) | |
| checkPatchList (self, patchList) | |
| getDcrModel (self, patchList, coaddRefs, visitInfo) | |
| _selectDataRef (coaddRef, tract, patch) | |
Variables | |
| detectorPolygon = geom.Box2D(bbox) | |
| int | overlappingArea = 0 |
| coaddExposures = collections.defaultdict(list) | |
| dataIds = collections.defaultdict(list) | |
| dataId = coaddRef.dataId | |
| patchWcs = skymap[dataId["tract"]].getWcs() | |
| patchBBox = skymap[dataId["tract"]][dataId["patch"]].getOuterBBox() | |
| patchCorners = patchWcs.pixelToSky(geom.Box2D(patchBBox).getCorners()) | |
| patchPolygon = afwGeom.Polygon(wcs.skyToPixel(patchCorners)) | |
| patchList = dict() | |
| subfilter = dataId["subfilter"] | |
Function Documentation
◆ _makeExposureCatalog()
|
protected |
Make an exposure catalog for one tract.
Parameters
----------
exposureRefs : `list` of [`lsst.daf.butler.DeferredDatasetHandle` of \
`lsst.afw.image.Exposure`]
Exposures to include in the catalog.
dataIds : `list` [`lsst.daf.butler.DataCoordinate`]
Data ids of each of the included exposures; must have "tract" and
"patch" entries.
Returns
-------
images : `dict` [`lsst.afw.image.MaskedImage`]
MaskedImages of each of the input exposures, for warping.
catalog : `lsst.afw.table.ExposureCatalog`
Catalog of metadata for each exposure
totalBox : `lsst.geom.Box2I`
The union of the bounding boxes of all the input exposures.
Definition at line 453 of file getTemplate.py.
453 def _makeExposureCatalog(self, exposureRefs, dataIds):
454 """Make an exposure catalog for one tract.
455
456 Parameters
457 ----------
458 exposureRefs : `list` of [`lsst.daf.butler.DeferredDatasetHandle` of \
459 `lsst.afw.image.Exposure`]
460 Exposures to include in the catalog.
461 dataIds : `list` [`lsst.daf.butler.DataCoordinate`]
462 Data ids of each of the included exposures; must have "tract" and
463 "patch" entries.
464
465 Returns
466 -------
467 images : `dict` [`lsst.afw.image.MaskedImage`]
468 MaskedImages of each of the input exposures, for warping.
469 catalog : `lsst.afw.table.ExposureCatalog`
470 Catalog of metadata for each exposure
471 totalBox : `lsst.geom.Box2I`
472 The union of the bounding boxes of all the input exposures.
473 """
474 catalog = afwTable.ExposureCatalog(self.schema)
475 catalog.reserve(len(exposureRefs))
476 exposures = (exposureRef.get() for exposureRef in exposureRefs)
477 images = {}
478 totalBox = geom.Box2I()
479
480 for coadd, dataId in zip(exposures, dataIds):
481 images[dataId] = coadd.maskedImage
482 bbox = coadd.getBBox()
483 totalBox = totalBox.expandedTo(bbox)
484 record = catalog.addNew()
485 record.setPsf(coadd.psf)
486 record.setWcs(coadd.wcs)
487 record.setPhotoCalib(coadd.photoCalib)
488 record.setBBox(bbox)
490 record.set("tract", dataId["tract"])
491 record.set("patch", dataId["patch"])
492 # Weight is used by CoaddPsf, but the PSFs from overlapping patches
493 # should be very similar, so this value mostly shouldn't matter.
494 record.set("weight", 1)
495
496 return images, catalog, totalBox
497
◆ _makePsf()
|
protected |
Return a PSF containing the PSF at each of the input regions.
Note that although this includes all the exposures from the catalog,
the PSF knows which part of the template the inputs came from, so when
evaluated at a given position it will not include inputs that never
went in to those pixels.
Parameters
----------
template : `lsst.afw.image.Exposure`
Generated template the PSF is for.
catalog : `lsst.afw.table.ExposureCatalog`
Catalog of exposures that went into the template that contains all
of the input PSFs.
wcs : `lsst.afw.geom.SkyWcs`
WCS of the template, to warp the PSFs to.
Returns
-------
coaddPsf : `lsst.meas.algorithms.CoaddPsf`
The meta-psf constructed from all of the input catalogs.
Definition at line 572 of file getTemplate.py.
572 def _makePsf(self, template, catalog, wcs):
573 """Return a PSF containing the PSF at each of the input regions.
574
575 Note that although this includes all the exposures from the catalog,
576 the PSF knows which part of the template the inputs came from, so when
577 evaluated at a given position it will not include inputs that never
578 went in to those pixels.
579
580 Parameters
581 ----------
582 template : `lsst.afw.image.Exposure`
583 Generated template the PSF is for.
584 catalog : `lsst.afw.table.ExposureCatalog`
585 Catalog of exposures that went into the template that contains all
586 of the input PSFs.
587 wcs : `lsst.afw.geom.SkyWcs`
588 WCS of the template, to warp the PSFs to.
589
590 Returns
591 -------
592 coaddPsf : `lsst.meas.algorithms.CoaddPsf`
593 The meta-psf constructed from all of the input catalogs.
594 """
595 # CoaddPsf centroid not only must overlap image, but must overlap the
596 # part of image with data. Use centroid of region with data.
597 boolmask = template.mask.array & template.mask.getPlaneBitMask("NO_DATA") == 0
598 maskx = afwImage.makeMaskFromArray(boolmask.astype(afwImage.MaskPixel))
599 centerCoord = afwGeom.SpanSet.fromMask(maskx, 1).computeCentroid()
600
601 ctrl = self.config.coaddPsf.makeControl()
602 coaddPsf = CoaddPsf(
603 catalog, wcs, centerCoord, ctrl.warpingKernelName, ctrl.cacheSize
604 )
605 return coaddPsf
606
607
◆ _merge()
|
protected |
Merge the images that came from one tract into one larger image,
ignoring NaN pixels and non-finite variance pixels from individual
exposures.
Parameters
----------
maskedImages : `dict` [`lsst.afw.image.MaskedImage` or
`lsst.afw.image.Exposure`]
Images to be merged into one larger bounding box.
bbox : `lsst.geom.Box2I`
Bounding box defining the image to merge into.
wcs : `lsst.afw.geom.SkyWcs`
WCS of all of the input images to set on the output image.
Returns
-------
merged : `lsst.afw.image.MaskedImage`
Merged image with all of the inputs at their respective bbox
positions.
count : `int`
Count of the number of good pixels (those with positive weights)
in the merged image.
included : `list` [`int`]
List of indexes of patches that were included in the merged
result, to be used to trim the exposure catalog.
Definition at line 498 of file getTemplate.py.
498 def _merge(self, maskedImages, bbox, wcs):
499 """Merge the images that came from one tract into one larger image,
500 ignoring NaN pixels and non-finite variance pixels from individual
501 exposures.
502
503 Parameters
504 ----------
505 maskedImages : `dict` [`lsst.afw.image.MaskedImage` or
506 `lsst.afw.image.Exposure`]
507 Images to be merged into one larger bounding box.
508 bbox : `lsst.geom.Box2I`
509 Bounding box defining the image to merge into.
510 wcs : `lsst.afw.geom.SkyWcs`
511 WCS of all of the input images to set on the output image.
512
513 Returns
514 -------
515 merged : `lsst.afw.image.MaskedImage`
516 Merged image with all of the inputs at their respective bbox
517 positions.
518 count : `int`
519 Count of the number of good pixels (those with positive weights)
520 in the merged image.
521 included : `list` [`int`]
522 List of indexes of patches that were included in the merged
523 result, to be used to trim the exposure catalog.
524 """
525 merged = afwImage.ExposureF(bbox, wcs)
526 weights = afwImage.ImageF(bbox)
527 included = [] # which patches were included in the result
528 for i, (dataId, maskedImage) in enumerate(maskedImages.items()):
529 # Only merge into the trimmed box, to save memory
530 clippedBox = geom.Box2I(maskedImage.getBBox())
531 clippedBox.clip(bbox)
532 if clippedBox.area == 0:
533 self.log.debug("%s does not overlap template region.", dataId)
534 continue # nothing in this image overlaps the output
535 maskedImage = maskedImage.subset(clippedBox)
536 # Catch both zero-value and NaN variance plane pixels
537 good = (maskedImage.variance.array > 0) & (
538 np.isfinite(maskedImage.variance.array)
539 )
540 weight = maskedImage.variance.array[good] ** (-0.5)
541 bad = np.isnan(maskedImage.image.array) | ~good
542 # Note that modifying the patch MaskedImage in place is fine;
543 # we're throwing it away at the end anyway.
544 maskedImage.image.array[bad] = 0.0
545 maskedImage.variance.array[bad] = 0.0
546 # Reset mask, too, since these pixels don't contribute to sum.
547 maskedImage.mask.array[bad] = 0
548 # Cannot use `merged.maskedImage *= weight` because that operator
549 # multiplies the variance by the weight twice; in this case
550 # `weight` are the exact values we want to scale by.
551 maskedImage.image.array[good] *= weight
552 maskedImage.variance.array[good] *= weight
553 weights[clippedBox].array[good] += weight
554 # Free memory before creating new large arrays
555 del weight
556 merged.maskedImage[clippedBox] += maskedImage
557 included.append(i)
558
559 good = weights.array > 0
560
561 # Cannot use `merged.maskedImage /= weights` because that
562 # operator divides the variance by the weight twice; in this case
563 # `weights` are the exact values we want to scale by.
564 weights = weights.array[good]
565 merged.image.array[good] /= weights
566 merged.variance.array[good] /= weights
567
568 merged.mask.array[~good] |= merged.mask.getPlaneBitMask("NO_DATA")
569
570 return merged, good.sum(), included
571
◆ _selectDataRef()
|
protected |
Definition at line 835 of file getTemplate.py.
835def _selectDataRef(coaddRef, tract, patch):
836 condition = (coaddRef.dataId["tract"] == tract) & (
837 coaddRef.dataId["patch"] == patch
838 )
839 return condition
◆ checkHighVariance()
| lsst.ip.diffim.getTemplate.checkHighVariance | ( | self, | |
| template ) |
Set a mask plane for regions with unusually high variance.
Parameters
----------
template : `lsst.afw.image.Exposure`
The warped template exposure, which will be modified in place.
Definition at line 386 of file getTemplate.py.
386 def checkHighVariance(self, template):
387 """Set a mask plane for regions with unusually high variance.
388
389 Parameters
390 ----------
391 template : `lsst.afw.image.Exposure`
392 The warped template exposure, which will be modified in place.
393 """
394 highVarianceMaskPlaneBit = template.mask.addMaskPlane("HIGH_VARIANCE")
395 ignoredPixelBits = template.mask.getPlaneBitMask(self.varianceBackground.config.ignoredPixelMask)
396 goodMask = (template.mask.array & ignoredPixelBits) == 0
397 goodFraction = np.count_nonzero(goodMask)/template.mask.array.size
398 if goodFraction < self.config.highVarianceMaskFraction:
399 self.log.info("Not setting HIGH_VARIANCE mask plane, only %2.1f%% of"
400 " pixels were unmasked for background estimation, but"
401 " %2.1f%% are required", 100*goodFraction, 100*self.config.highVarianceMaskFraction)
402 else:
403 varianceExposure = template.clone()
404 varianceExposure.image.array = varianceExposure.variance.array
405 varianceBackground = self.varianceBackground.run(varianceExposure).background.getImage().array
406 threshold = self.config.highVarianceThreshold*np.nanmedian(varianceBackground)
407 highVariancePix = varianceBackground > threshold
408 template.mask.array[highVariancePix] |= 2**highVarianceMaskPlaneBit
409
◆ checkPatchList()
| lsst.ip.diffim.getTemplate.checkPatchList | ( | self, | |
| patchList ) |
Check that all of the DcrModel subfilters are present for each
patch.
Parameters
----------
patchList : `dict`
Dict of the patches containing valid data for each tract.
Raises
------
RuntimeError
If the number of exposures found for a patch does not match the
number of subfilters.
Definition at line 774 of file getTemplate.py.
774 def checkPatchList(self, patchList):
775 """Check that all of the DcrModel subfilters are present for each
776 patch.
777
778 Parameters
779 ----------
780 patchList : `dict`
781 Dict of the patches containing valid data for each tract.
782
783 Raises
784 ------
785 RuntimeError
786 If the number of exposures found for a patch does not match the
787 number of subfilters.
788 """
789 for tract in patchList:
790 for patch in set(patchList[tract]):
791 if patchList[tract].count(patch) != self.config.numSubfilters:
792 raise RuntimeError(
793 "Invalid number of DcrModel subfilters found: %d vs %d expected",
794 patchList[tract].count(patch),
795 self.config.numSubfilters,
796 )
797
◆ getDcrModel()
| lsst.ip.diffim.getTemplate.getDcrModel | ( | self, | |
| patchList, | |||
| coaddRefs, | |||
| visitInfo ) |
Build DCR-matched coadds from a list of exposure references.
Parameters
----------
patchList : `dict`
Dict of the patches containing valid data for each tract.
coaddRefs : `list` [`lsst.daf.butler.DeferredDatasetHandle`]
Data references to `~lsst.afw.image.Exposure` representing
DcrModels that overlap the detector.
visitInfo : `lsst.afw.image.VisitInfo`
Metadata for the science image.
Returns
-------
coaddExposures : `list` [`lsst.afw.image.Exposure`]
Coadd exposures that overlap the detector.
Definition at line 798 of file getTemplate.py.
798 def getDcrModel(self, patchList, coaddRefs, visitInfo):
799 """Build DCR-matched coadds from a list of exposure references.
800
801 Parameters
802 ----------
803 patchList : `dict`
804 Dict of the patches containing valid data for each tract.
805 coaddRefs : `list` [`lsst.daf.butler.DeferredDatasetHandle`]
806 Data references to `~lsst.afw.image.Exposure` representing
807 DcrModels that overlap the detector.
808 visitInfo : `lsst.afw.image.VisitInfo`
809 Metadata for the science image.
810
811 Returns
812 -------
813 coaddExposures : `list` [`lsst.afw.image.Exposure`]
814 Coadd exposures that overlap the detector.
815 """
816 coaddExposures = collections.defaultdict(list)
817 for tract in patchList:
818 for patch in set(patchList[tract]):
819 coaddRefList = [
820 coaddRef
821 for coaddRef in coaddRefs
822 if _selectDataRef(coaddRef, tract, patch)
823 ]
824
825 dcrModel = DcrModel.fromQuantum(
826 coaddRefList,
827 self.config.effectiveWavelength,
828 self.config.bandwidth,
829 self.config.numSubfilters,
830 )
831 coaddExposures[tract].append(dcrModel.buildMatchedExposureHandle(visitInfo=visitInfo))
832 return coaddExposures
833
834
◆ run()
| lsst.ip.diffim.getTemplate.run | ( | self, | |
| * | , | ||
| coaddExposureHandles, | |||
| bbox, | |||
| wcs, | |||
| dataIds, | |||
| physical_filter ) |
Warp coadds from multiple tracts and patches to form a template to
subtract from a science image.
Tract and patch overlap regions are combined by a variance-weighted
average, and the variance planes are combined with the same weights,
not added in quadrature; the overlap regions are not statistically
independent, because they're derived from the same original data.
The PSF on the template is created by combining the CoaddPsf on each
template image into a meta-CoaddPsf.
Parameters
----------
coaddExposureHandles : `dict` [`int`, `list` of \
[`lsst.daf.butler.DeferredDatasetHandle` of \
`lsst.afw.image.Exposure`]]
Coadds to be mosaicked, indexed on tract id.
bbox : `lsst.geom.Box2I`
Template Bounding box of the detector geometry onto which to
resample the ``coaddExposureHandles``. Modified in-place to include the
template border.
wcs : `lsst.afw.geom.SkyWcs`
Template WCS onto which to resample the ``coaddExposureHandles``.
dataIds : `dict` [`int`, `list` [`lsst.daf.butler.DataCoordinate`]]
Record of the tract and patch of each coaddExposure, indexed on
tract id.
physical_filter : `str`
Physical filter of the science image.
Returns
-------
result : `lsst.pipe.base.Struct`
A struct with attributes:
``template``
A template coadd exposure assembled out of patches
(`lsst.afw.image.ExposureF`).
Raises
------
NoWorkFound
If no coadds are found with sufficient un-masked pixels.
Definition at line 274 of file getTemplate.py.
274 def run(self, *, coaddExposureHandles, bbox, wcs, dataIds, physical_filter):
275 """Warp coadds from multiple tracts and patches to form a template to
276 subtract from a science image.
277
278 Tract and patch overlap regions are combined by a variance-weighted
279 average, and the variance planes are combined with the same weights,
280 not added in quadrature; the overlap regions are not statistically
281 independent, because they're derived from the same original data.
282 The PSF on the template is created by combining the CoaddPsf on each
283 template image into a meta-CoaddPsf.
284
285 Parameters
286 ----------
287 coaddExposureHandles : `dict` [`int`, `list` of \
288 [`lsst.daf.butler.DeferredDatasetHandle` of \
289 `lsst.afw.image.Exposure`]]
290 Coadds to be mosaicked, indexed on tract id.
291 bbox : `lsst.geom.Box2I`
292 Template Bounding box of the detector geometry onto which to
293 resample the ``coaddExposureHandles``. Modified in-place to include the
294 template border.
295 wcs : `lsst.afw.geom.SkyWcs`
296 Template WCS onto which to resample the ``coaddExposureHandles``.
297 dataIds : `dict` [`int`, `list` [`lsst.daf.butler.DataCoordinate`]]
298 Record of the tract and patch of each coaddExposure, indexed on
299 tract id.
300 physical_filter : `str`
301 Physical filter of the science image.
302
303 Returns
304 -------
305 result : `lsst.pipe.base.Struct`
306 A struct with attributes:
307
308 ``template``
309 A template coadd exposure assembled out of patches
310 (`lsst.afw.image.ExposureF`).
311
312 Raises
313 ------
314 NoWorkFound
315 If no coadds are found with sufficient un-masked pixels.
316 """
317 band, photoCalib = self._checkInputs(dataIds, coaddExposureHandles)
318
319 bbox.grow(self.config.templateBorderSize)
320
321 warped = {}
322 catalogs = []
323 for tract in coaddExposureHandles:
324 maskedImages, catalog, totalBox = self._makeExposureCatalog(
325 coaddExposureHandles[tract], dataIds[tract]
326 )
327 warpedBox = computeWarpedBBox(catalog[0].wcs, bbox, wcs)
328 warpedBox.grow(5) # to ensure we catch all relevant input pixels
329 # Combine images from individual patches together.
330 unwarped, count, included = self._merge(
331 maskedImages, warpedBox, catalog[0].wcs
332 )
333 # Delete `maskedImages` after combining into one large image to reduce peak memory use
334 del maskedImages
335 if count == 0:
336 self.log.info(
337 "No valid pixels from coadd patches in tract %s; not including in output.",
338 tract,
339 )
340 continue
341 warpedBox.clip(totalBox)
342 potentialInput = self.warper.warpExposure(
343 wcs, unwarped.subset(warpedBox), destBBox=bbox
344 )
345
346 # Delete the single large `unwarped` image after warping to reduce peak memory use
347 del unwarped
348 if np.all(
349 potentialInput.mask.array
350 & potentialInput.mask.getPlaneBitMask("NO_DATA")
351 ):
352 self.log.info(
353 "No overlap from coadd patches in tract %s; not including in output.",
354 tract,
355 )
356 continue
357
358 # Trim the exposure catalog to just the patches that were used.
359 tempCatalog = afwTable.ExposureCatalog(self.schema)
360 tempCatalog.reserve(len(included))
361 for i in included:
362 tempCatalog.append(catalog[i])
363 catalogs.append(tempCatalog)
364 warped[tract] = potentialInput.maskedImage
365
366 if len(warped) == 0:
367 raise pipeBase.NoWorkFound("No patches found to overlap science exposure.")
368 # At this point, all entries will be valid, so we can ignore included.
369 template, count, _ = self._merge(warped, bbox, wcs)
370 if count == 0:
371 raise pipeBase.NoWorkFound("No valid pixels in warped template.")
372
373 # Make a single catalog containing all the inputs that were accepted.
374 catalog = afwTable.ExposureCatalog(self.schema)
375 catalog.reserve(sum([len(c) for c in catalogs]))
376 for c in catalogs:
377 catalog.extend(c)
378
379 # Set a mask plane for any regions with exceptionally high variance.
380 self.checkHighVariance(template)
381 template.setPsf(self._makePsf(template, catalog, wcs))
382 template.setFilter(afwImage.FilterLabel(band, physical_filter))
383 template.setPhotoCalib(photoCalib)
384 return pipeBase.Struct(template=template)
385
A group of labels for a filter in an exposure or coadd.
Definition FilterLabel.h:58
Variable Documentation
◆ coaddExposures
| lsst.ip.diffim.getTemplate.coaddExposures = collections.defaultdict(list) |
Definition at line 247 of file getTemplate.py.
◆ dataId
| lsst.ip.diffim.getTemplate.dataId = coaddRef.dataId |
Definition at line 251 of file getTemplate.py.
◆ dataIds
| lsst.ip.diffim.getTemplate.dataIds = collections.defaultdict(list) |
Definition at line 248 of file getTemplate.py.
◆ detectorPolygon
| lsst.ip.diffim.getTemplate.detectorPolygon = geom.Box2D(bbox) |
Definition at line 245 of file getTemplate.py.
◆ overlappingArea
| int lsst.ip.diffim.getTemplate.overlappingArea = 0 |
Definition at line 246 of file getTemplate.py.
◆ patchBBox
Definition at line 253 of file getTemplate.py.
◆ patchCorners
| lsst.ip.diffim.getTemplate.patchCorners = patchWcs.pixelToSky(geom.Box2D(patchBBox).getCorners()) |
Definition at line 254 of file getTemplate.py.
◆ patchList
| lsst.ip.diffim.getTemplate.patchList = dict() |
Definition at line 741 of file getTemplate.py.
◆ patchPolygon
| lsst.ip.diffim.getTemplate.patchPolygon = afwGeom.Polygon(wcs.skyToPixel(patchCorners)) |
Definition at line 255 of file getTemplate.py.
◆ patchWcs
| lsst.ip.diffim.getTemplate.patchWcs = skymap[dataId["tract"]].getWcs() |
Definition at line 252 of file getTemplate.py.
◆ subfilter
| lsst.ip.diffim.getTemplate.subfilter = dataId["subfilter"] |
Definition at line 744 of file getTemplate.py.
Generated on Sun Oct 12 2025 07:02:45 for LSST Applications by
1.13.2