|
def | __init__ (self, args, kwargs) |
|
def | getOutputDatasetTypes (cls, config) |
|
def | getInputDatasetTypes (cls, config) |
|
def | adaptArgsAndRun (self, inputData, inputDataIds, outputDataIds, butler) |
|
def | runDataRef (self, dataRef, selectDataList=None, warpRefList=None) |
|
def | processResults (self, coaddExposure, dataRef) |
|
def | makeSupplementaryData (self, dataRef, selectDataList=None, warpRefList=None) |
|
def | makeSupplementaryDataGen3 (self, inputData, inputDataIds, outputDataIds, butler) |
|
def | getTempExpRefList (self, patchRef, calExpRefList) |
|
def | prepareInputs (self, refList) |
|
def | prepareStats (self, mask=None) |
|
def | run (self, skyInfo, tempExpRefList, imageScalerList, weightList, altMaskList=None, mask=None, supplementaryData=None) |
|
def | assembleMetadata (self, coaddExposure, tempExpRefList, weightList) |
|
def | assembleSubregion (self, coaddExposure, bbox, tempExpRefList, imageScalerList, weightList, altMaskList, statsFlags, statsCtrl, nImage=None) |
|
def | removeMaskPlanes (self, maskedImage) |
|
def | applyAltMaskPlanes (self, mask, altMaskSpans) |
|
def | shrinkValidPolygons (self, coaddInputs) |
|
def | readBrightObjectMasks (self, dataRef) |
|
def | setBrightObjectMasks (self, exposure, dataId, brightObjectMasks) |
|
def | setInexactPsf (self, mask) |
|
def | selectExposures (self, patchRef, skyInfo=None, selectDataList=[]) |
| Select exposures to coadd. More...
|
|
def | getSkyInfo (self, patchRef) |
| Use getSkyinfo to return the skyMap, tract and patch information, wcs and the outer bbox of the patch. More...
|
|
def | getCoaddDatasetName (self, warpType="direct") |
|
def | getTempExpDatasetName (self, warpType="direct") |
|
def | getBadPixelMask (self) |
| Convenience method to provide the bitmask from the mask plane names. More...
|
|
Assemble a coadded image from a set of warps (coadded temporary exposures).
We want to assemble a coadded image from a set of Warps (also called
coadded temporary exposures or ``coaddTempExps``).
Each input Warp covers a patch on the sky and corresponds to a single
run/visit/exposure of the covered patch. We provide the task with a list
of Warps (``selectDataList``) from which it selects Warps that cover the
specified patch (pointed at by ``dataRef``).
Each Warp that goes into a coadd will typically have an independent
photometric zero-point. Therefore, we must scale each Warp to set it to
a common photometric zeropoint. WarpType may be one of 'direct' or
'psfMatched', and the boolean configs `config.makeDirect` and
`config.makePsfMatched` set which of the warp types will be coadded.
The coadd is computed as a mean with optional outlier rejection.
Criteria for outlier rejection are set in `AssembleCoaddConfig`.
Finally, Warps can have bad 'NaN' pixels which received no input from the
source calExps. We interpolate over these bad (NaN) pixels.
`AssembleCoaddTask` uses several sub-tasks. These are
- `ScaleZeroPointTask`
- create and use an ``imageScaler`` object to scale the photometric zeropoint for each Warp
- `InterpImageTask`
- interpolate across bad pixels (NaN) in the final coadd
You can retarget these subtasks if you wish.
Notes
-----
The `lsst.pipe.base.cmdLineTask.CmdLineTask` interface supports a
flag ``-d`` to import ``debug.py`` from your ``PYTHONPATH``; see
`baseDebug` for more about ``debug.py`` files. `AssembleCoaddTask` has
no debug variables of its own. Some of the subtasks may support debug
variables. See the documentation for the subtasks for further information.
Examples
--------
`AssembleCoaddTask` assembles a set of warped images into a coadded image.
The `AssembleCoaddTask` can be invoked by running ``assembleCoadd.py``
with the flag '--legacyCoadd'. Usage of assembleCoadd.py expects two
inputs: a data reference to the tract patch and filter to be coadded, and
a list of Warps to attempt to coadd. These are specified using ``--id`` and
``--selectId``, respectively:
.. code-block:: none
--id = [KEY=VALUE1[^VALUE2[^VALUE3...] [KEY=VALUE1[^VALUE2[^VALUE3...] ...]]
--selectId [KEY=VALUE1[^VALUE2[^VALUE3...] [KEY=VALUE1[^VALUE2[^VALUE3...] ...]]
Only the Warps that cover the specified tract and patch will be coadded.
A list of the available optional arguments can be obtained by calling
``assembleCoadd.py`` with the ``--help`` command line argument:
.. code-block:: none
assembleCoadd.py --help
To demonstrate usage of the `AssembleCoaddTask` in the larger context of
multi-band processing, we will generate the HSC-I & -R band coadds from
HSC engineering test data provided in the ``ci_hsc`` package. To begin,
assuming that the lsst stack has been already set up, we must set up the
obs_subaru and ``ci_hsc`` packages. This defines the environment variable
``$CI_HSC_DIR`` and points at the location of the package. The raw HSC
data live in the ``$CI_HSC_DIR/raw directory``. To begin assembling the
coadds, we must first
- processCcd
- process the individual ccds in $CI_HSC_RAW to produce calibrated exposures
- makeSkyMap
- create a skymap that covers the area of the sky present in the raw exposures
- makeCoaddTempExp
- warp the individual calibrated exposures to the tangent plane of the coadd
We can perform all of these steps by running
.. code-block:: none
$CI_HSC_DIR scons warp-903986 warp-904014 warp-903990 warp-904010 warp-903988
This will produce warped exposures for each visit. To coadd the warped
data, we call assembleCoadd.py as follows:
.. code-block:: none
assembleCoadd.py --legacyCoadd $CI_HSC_DIR/DATA --id patch=5,4 tract=0 filter=HSC-I \
--selectId visit=903986 ccd=16 --selectId visit=903986 ccd=22 --selectId visit=903986 ccd=23 \
--selectId visit=903986 ccd=100 --selectId visit=904014 ccd=1 --selectId visit=904014 ccd=6 \
--selectId visit=904014 ccd=12 --selectId visit=903990 ccd=18 --selectId visit=903990 ccd=25 \
--selectId visit=904010 ccd=4 --selectId visit=904010 ccd=10 --selectId visit=904010 ccd=100 \
--selectId visit=903988 ccd=16 --selectId visit=903988 ccd=17 --selectId visit=903988 ccd=23 \
--selectId visit=903988 ccd=24
that will process the HSC-I band data. The results are written in
``$CI_HSC_DIR/DATA/deepCoadd-results/HSC-I``.
You may also choose to run:
.. code-block:: none
scons warp-903334 warp-903336 warp-903338 warp-903342 warp-903344 warp-903346
assembleCoadd.py --legacyCoadd $CI_HSC_DIR/DATA --id patch=5,4 tract=0 filter=HSC-R \
--selectId visit=903334 ccd=16 --selectId visit=903334 ccd=22 --selectId visit=903334 ccd=23 \
--selectId visit=903334 ccd=100 --selectId visit=903336 ccd=17 --selectId visit=903336 ccd=24 \
--selectId visit=903338 ccd=18 --selectId visit=903338 ccd=25 --selectId visit=903342 ccd=4 \
--selectId visit=903342 ccd=10 --selectId visit=903342 ccd=100 --selectId visit=903344 ccd=0 \
--selectId visit=903344 ccd=5 --selectId visit=903344 ccd=11 --selectId visit=903346 ccd=1 \
--selectId visit=903346 ccd=6 --selectId visit=903346 ccd=12
to generate the coadd for the HSC-R band if you are interested in
following multiBand Coadd processing as discussed in `pipeTasks_multiBand`
(but note that normally, one would use the `SafeClipAssembleCoaddTask`
rather than `AssembleCoaddTask` to make the coadd.
Definition at line 221 of file assembleCoadd.py.
def lsst.pipe.tasks.assembleCoadd.AssembleCoaddTask.adaptArgsAndRun |
( |
|
self, |
|
|
|
inputData, |
|
|
|
inputDataIds, |
|
|
|
outputDataIds, |
|
|
|
butler |
|
) |
| |
Assemble a coadd from a set of Warps.
PipelineTask (Gen3) entry point to Coadd a set of Warps.
Analogous to `runDataRef`, it prepares all the data products to be
passed to `run`, and processes the results before returning to struct
of results to be written out. AssembleCoadd cannot fit all Warps in memory.
Therefore, its inputs are accessed subregion by subregion
by the `lsst.daf.butler.ShimButler` that quacks like a Gen2
`lsst.daf.persistence.Butler`. Updates to this method should
correspond to an update in `runDataRef` while both entry points
are used.
Parameters
----------
inputData : `dict`
Keys are the names of the configs describing input dataset types.
Values are input Python-domain data objects (or lists of objects)
retrieved from data butler.
inputDataIds : `dict`
Keys are the names of the configs describing input dataset types.
Values are DataIds (or lists of DataIds) that task consumes for
corresponding dataset type.
outputDataIds : `dict`
Keys are the names of the configs describing input dataset types.
Values are DataIds (or lists of DataIds) that task is to produce
for corresponding dataset type.
butler : `lsst.daf.butler.Butler`
Gen3 Butler object for fetching additional data products before
running the Task
Returns
-------
result : `lsst.pipe.base.Struct`
Result struct with components:
- ``coaddExposure`` : coadded exposure (``lsst.afw.image.Exposure``)
- ``nImage``: N Image (``lsst.afw.image.Image``)
Definition at line 383 of file assembleCoadd.py.
def lsst.pipe.tasks.assembleCoadd.AssembleCoaddTask.assembleSubregion |
( |
|
self, |
|
|
|
coaddExposure, |
|
|
|
bbox, |
|
|
|
tempExpRefList, |
|
|
|
imageScalerList, |
|
|
|
weightList, |
|
|
|
altMaskList, |
|
|
|
statsFlags, |
|
|
|
statsCtrl, |
|
|
|
nImage = None |
|
) |
| |
Assemble the coadd for a sub-region.
For each coaddTempExp, check for (and swap in) an alternative mask
if one is passed. Remove mask planes listed in
`config.removeMaskPlanes`. Finally, stack the actual exposures using
`lsst.afw.math.statisticsStack` with the statistic specified by
statsFlags. Typically, the statsFlag will be one of lsst.afw.math.MEAN for
a mean-stack or `lsst.afw.math.MEANCLIP` for outlier rejection using
an N-sigma clipped mean where N and iterations are specified by
statsCtrl. Assign the stacked subregion back to the coadd.
Parameters
----------
coaddExposure : `lsst.afw.image.Exposure`
The target exposure for the coadd.
bbox : `lsst.afw.geom.Box`
Sub-region to coadd.
tempExpRefList : `list`
List of data reference to tempExp.
imageScalerList : `list`
List of image scalers.
weightList : `list`
List of weights.
altMaskList : `list`
List of alternate masks to use rather than those stored with
tempExp, or None. Each element is dict with keys = mask plane
name to which to add the spans.
statsFlags : `lsst.afw.math.Property`
Property object for statistic for coadd.
statsCtrl : `lsst.afw.math.StatisticsControl`
Statistics control object for coadd.
nImage : `lsst.afw.image.ImageU`, optional
Keeps track of exposure count for each pixel.
Definition at line 855 of file assembleCoadd.py.
def lsst.pipe.tasks.assembleCoadd.AssembleCoaddTask.run |
( |
|
self, |
|
|
|
skyInfo, |
|
|
|
tempExpRefList, |
|
|
|
imageScalerList, |
|
|
|
weightList, |
|
|
|
altMaskList = None , |
|
|
|
mask = None , |
|
|
|
supplementaryData = None |
|
) |
| |
Assemble a coadd from input warps
Assemble the coadd using the provided list of coaddTempExps. Since
the full coadd covers a patch (a large area), the assembly is
performed over small areas on the image at a time in order to
conserve memory usage. Iterate over subregions within the outer
bbox of the patch using `assembleSubregion` to stack the corresponding
subregions from the coaddTempExps with the statistic specified.
Set the edge bits the coadd mask based on the weight map.
Parameters
----------
skyInfo : `lsst.pipe.base.Struct`
Struct with geometric information about the patch.
tempExpRefList : `list`
List of data references to Warps (previously called CoaddTempExps).
imageScalerList : `list`
List of image scalers.
weightList : `list`
List of weights
altMaskList : `list`, optional
List of alternate masks to use rather than those stored with
tempExp.
mask : `lsst.afw.image.Mask`, optional
Mask to ignore when coadding
supplementaryData : lsst.pipe.base.Struct, optional
Struct with additional data products needed to assemble coadd.
Only used by subclasses that implement `makeSupplementaryData`
and override `run`.
Returns
-------
result : `lsst.pipe.base.Struct`
Result struct with components:
- ``coaddExposure``: coadded exposure (``lsst.afw.image.Exposure``).
- ``nImage``: exposure count image (``lsst.afw.image.Image``).
Definition at line 726 of file assembleCoadd.py.
def lsst.pipe.tasks.assembleCoadd.AssembleCoaddTask.setRejectedMaskMapping |
( |
|
statsCtrl | ) |
|
|
static |
Map certain mask planes of the warps to new planes for the coadd.
If a pixel is rejected due to a mask value other than EDGE, NO_DATA,
or CLIPPED, set it to REJECTED on the coadd.
If a pixel is rejected due to EDGE, set the coadd pixel to SENSOR_EDGE.
If a pixel is rejected due to CLIPPED, set the coadd pixel to CLIPPED.
Parameters
----------
statsCtrl : `lsst.afw.math.StatisticsControl`
Statistics control object for coadd
Returns
-------
maskMap : `list` of `tuple` of `int`
A list of mappings of mask planes of the warped exposures to
mask planes of the coadd.
Definition at line 940 of file assembleCoadd.py.