lsst.pipe.tasks.characterizeImage.CharacterizeImageTask Class Reference

Inheritance diagram for lsst.pipe.tasks.characterizeImage.CharacterizeImageTask:

Public Member Functions
	__init__ (self, schema=None, **kwargs)
	runQuantum (self, butlerQC, inputRefs, outputRefs)
	run (self, exposure, background=None, idGenerator=None)
	detectMeasureAndEstimatePsf (self, exposure, idGenerator, background)
	display (self, itemName, exposure, sourceCat=None)

Public Attributes
	schema
	algMetadata
	outputSchema

Static Public Attributes
	ConfigClass = CharacterizeImageConfig

Protected Attributes
	_initialFrame
	_frame

Static Protected Attributes
str	_DefaultName = "characterizeImage"

Detailed Description

Measure bright sources and use this to estimate background and PSF of
an exposure.

Given an exposure with defects repaired (masked and interpolated over,
e.g. as output by `~lsst.ip.isr.IsrTask`):
- detect and measure bright sources
- repair cosmic rays
- detect and mask streaks
- measure and subtract background
- measure PSF

Parameters
----------
schema : `lsst.afw.table.Schema`, optional
    Initial schema for icSrc catalog.
**kwargs
    Additional keyword arguments.

Notes
-----
Debugging:
CharacterizeImageTask has a debug dictionary with the following keys:

frame
    int: if specified, the frame of first debug image displayed (defaults to 1)
repair_iter
    bool; if True display image after each repair in the measure PSF loop
background_iter
    bool; if True display image after each background subtraction in the measure PSF loop
measure_iter
    bool; if True display image and sources at the end of each iteration of the measure PSF loop
    See `~lsst.meas.astrom.displayAstrometry` for the meaning of the various symbols.
psf
    bool; if True display image and sources after PSF is measured;
    this will be identical to the final image displayed by measure_iter if measure_iter is true
repair
    bool; if True display image and sources after final repair
measure
    bool; if True display image and sources after final measurement

Definition at line 265 of file characterizeImage.py.

Constructor & Destructor Documentation

__init__()

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask.__init__	(		self,
			schema = None,
		**	kwargs )

Definition at line 310 of file characterizeImage.py.

    def __init__(self, schema=None, **kwargs):
        super().__init__(**kwargs)
 
        if schema is None:
            schema = SourceTable.makeMinimalSchema()
        self.schema = schema
        self.makeSubtask("background")
        self.makeSubtask("installSimplePsf")
        self.makeSubtask("repair")
        if self.config.doMaskStreaks:
            self.makeSubtask("maskStreaks")
        self.makeSubtask("measurePsf", schema=self.schema)
        self.algMetadata = dafBase.PropertyList()
        self.makeSubtask('detection', schema=self.schema)
        if self.config.doDeblend:
            self.makeSubtask("deblend", schema=self.schema)
        self.makeSubtask('measurement', schema=self.schema, algMetadata=self.algMetadata)
        if self.config.doApCorr:
            self.makeSubtask('measureApCorr', schema=self.schema)
            self.makeSubtask('applyApCorr', schema=self.schema)
        self.makeSubtask('catalogCalculation', schema=self.schema)
        self._initialFrame = getDebugFrame(self._display, "frame") or 1
        self._frame = self._initialFrame
        self.schema.checkUnits(parse_strict=self.config.checkUnitsParseStrict)
        self.outputSchema = afwTable.SourceCatalog(self.schema)
 

Member Function Documentation

detectMeasureAndEstimatePsf()

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask.detectMeasureAndEstimatePsf	(		self,
			exposure,
			idGenerator,
			background )

Perform one iteration of detect, measure, and estimate PSF.

Performs the following operations:

- if config.doMeasurePsf or not exposure.hasPsf():

    - install a simple PSF model (replacing the existing one, if need be)

- interpolate over cosmic rays with keepCRs=True
- estimate background and subtract it from the exposure
- detect, deblend and measure sources, and subtract a refined background model;
- if config.doMeasurePsf:
    - measure PSF

Parameters
----------
exposure : `lsst.afw.image.ExposureF`
    Exposure to characterize.
idGenerator : `lsst.meas.base.IdGenerator`
    Object that generates source IDs and provides RNG seeds.
background : `lsst.afw.math.BackgroundList`, optional
    Initial model of background already subtracted from exposure.

Returns
-------
result : `lsst.pipe.base.Struct`
    Results as a struct with attributes:

    ``exposure``
       Characterized exposure (`lsst.afw.image.ExposureF`).
    ``sourceCat``
       Detected sources (`lsst.afw.table.SourceCatalog`).
    ``background``
       Model of subtracted background (`lsst.afw.math.BackgroundList`).
    ``psfCellSet``
       Spatial cells of PSF candidates (`lsst.afw.math.SpatialCellSet`).

Raises
------
LengthError
    Raised if there are too many CR pixels.

Definition at line 460 of file characterizeImage.py.

    def detectMeasureAndEstimatePsf(self, exposure, idGenerator, background):
        """Perform one iteration of detect, measure, and estimate PSF.
 
        Performs the following operations:
 
        - if config.doMeasurePsf or not exposure.hasPsf():
 
            - install a simple PSF model (replacing the existing one, if need be)
 
        - interpolate over cosmic rays with keepCRs=True
        - estimate background and subtract it from the exposure
        - detect, deblend and measure sources, and subtract a refined background model;
        - if config.doMeasurePsf:
            - measure PSF
 
        Parameters
        ----------
        exposure : `lsst.afw.image.ExposureF`
            Exposure to characterize.
        idGenerator : `lsst.meas.base.IdGenerator`
            Object that generates source IDs and provides RNG seeds.
        background : `lsst.afw.math.BackgroundList`, optional
            Initial model of background already subtracted from exposure.
 
        Returns
        -------
        result : `lsst.pipe.base.Struct`
            Results as a struct with attributes:
 
            ``exposure``
               Characterized exposure (`lsst.afw.image.ExposureF`).
            ``sourceCat``
               Detected sources (`lsst.afw.table.SourceCatalog`).
            ``background``
               Model of subtracted background (`lsst.afw.math.BackgroundList`).
            ``psfCellSet``
               Spatial cells of PSF candidates (`lsst.afw.math.SpatialCellSet`).
 
        Raises
        ------
        LengthError
            Raised if there are too many CR pixels.
        """
        # install a simple PSF model, if needed or wanted
        if not exposure.hasPsf() or (self.config.doMeasurePsf and self.config.useSimplePsf):
            self.log.info("PSF estimation initialized with 'simple' PSF")
            self.installSimplePsf.run(exposure=exposure)
 
        # run repair, but do not interpolate over cosmic rays (do that elsewhere, with the final PSF model)
        if self.config.requireCrForPsf:
            self.repair.run(exposure=exposure, keepCRs=True)
        else:
            try:
                self.repair.run(exposure=exposure, keepCRs=True)
            except LengthError:
                self.log.warning("Skipping cosmic ray detection: Too many CR pixels (max %0.f)",
                                 self.config.repair.cosmicray.nCrPixelMax)
 
        self.display("repair_iter", exposure=exposure)
 
        if background is None:
            background = BackgroundList()
 
        sourceIdFactory = idGenerator.make_table_id_factory()
        table = SourceTable.make(self.schema, sourceIdFactory)
        table.setMetadata(self.algMetadata)
 
        detRes = self.detection.run(table=table, exposure=exposure, doSmooth=True)
        sourceCat = detRes.sources
        if detRes.background:
            for bg in detRes.background:
                background.append(bg)
 
        if self.config.doDeblend:
            self.deblend.run(exposure=exposure, sources=sourceCat)
            # We need the output catalog to be contiguous for further processing.
            if not sourceCat.isContiguous():
                sourceCat = sourceCat.copy(deep=True)
 
        self.measurement.run(measCat=sourceCat, exposure=exposure, exposureId=idGenerator.catalog_id)
 
        measPsfRes = pipeBase.Struct(cellSet=None)
        if self.config.doMeasurePsf:
            measPsfRes = self.measurePsf.run(exposure=exposure, sources=sourceCat,
                                             expId=idGenerator.catalog_id)
        self.display("measure_iter", exposure=exposure, sourceCat=sourceCat)
 
        return pipeBase.Struct(
            exposure=exposure,
            sourceCat=sourceCat,
            background=background,
            psfCellSet=measPsfRes.cellSet,
        )
 

display()

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask.display	(		self,
			itemName,
			exposure,
			sourceCat = None )

Display exposure and sources on next frame (for debugging).

Parameters
----------
itemName : `str`
    Name of item in ``debugInfo``.
exposure : `lsst.afw.image.ExposureF`
    Exposure to display.
sourceCat : `lsst.afw.table.SourceCatalog`, optional
    Catalog of sources detected on the exposure.

Definition at line 554 of file characterizeImage.py.

    def display(self, itemName, exposure, sourceCat=None):
        """Display exposure and sources on next frame (for debugging).
 
        Parameters
        ----------
        itemName : `str`
            Name of item in ``debugInfo``.
        exposure : `lsst.afw.image.ExposureF`
            Exposure to display.
        sourceCat : `lsst.afw.table.SourceCatalog`, optional
            Catalog of sources detected on the exposure.
        """
        val = getDebugFrame(self._display, itemName)
        if not val:
            return
 
        displayAstrometry(exposure=exposure, sourceCat=sourceCat, frame=self._frame, pause=False)
        self._frame += 1

run()

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask.run	(		self,
			exposure,
			background = None,
			idGenerator = None )

Characterize a science image.

Peforms the following operations:
- Iterate the following config.psfIterations times, or once if config.doMeasurePsf false:
    - detect and measure sources and estimate PSF (see detectMeasureAndEstimatePsf for details)
- interpolate over cosmic rays
- perform final measurement

Parameters
----------
exposure : `lsst.afw.image.ExposureF`
    Exposure to characterize.
background : `lsst.afw.math.BackgroundList`, optional
    Initial model of background already subtracted from exposure.
idGenerator : `lsst.meas.base.IdGenerator`, optional
    Object that generates source IDs and provides RNG seeds.

Returns
-------
result : `lsst.pipe.base.Struct`
    Results as a struct with attributes:

    ``exposure``
       Characterized exposure (`lsst.afw.image.ExposureF`).
    ``sourceCat``
       Detected sources (`lsst.afw.table.SourceCatalog`).
    ``background``
       Model of subtracted background (`lsst.afw.math.BackgroundList`).
    ``psfCellSet``
       Spatial cells of PSF candidates (`lsst.afw.math.SpatialCellSet`).
    ``characterized``
       Another reference to ``exposure`` for compatibility.
    ``backgroundModel``
       Another reference to ``background`` for compatibility.

Raises
------
RuntimeError
    Raised if PSF sigma is NaN.

Definition at line 344 of file characterizeImage.py.

    def run(self, exposure, background=None, idGenerator=None):
        """Characterize a science image.
 
        Peforms the following operations:
        - Iterate the following config.psfIterations times, or once if config.doMeasurePsf false:
            - detect and measure sources and estimate PSF (see detectMeasureAndEstimatePsf for details)
        - interpolate over cosmic rays
        - perform final measurement
 
        Parameters
        ----------
        exposure : `lsst.afw.image.ExposureF`
            Exposure to characterize.
        background : `lsst.afw.math.BackgroundList`, optional
            Initial model of background already subtracted from exposure.
        idGenerator : `lsst.meas.base.IdGenerator`, optional
            Object that generates source IDs and provides RNG seeds.
 
        Returns
        -------
        result : `lsst.pipe.base.Struct`
            Results as a struct with attributes:
 
            ``exposure``
               Characterized exposure (`lsst.afw.image.ExposureF`).
            ``sourceCat``
               Detected sources (`lsst.afw.table.SourceCatalog`).
            ``background``
               Model of subtracted background (`lsst.afw.math.BackgroundList`).
            ``psfCellSet``
               Spatial cells of PSF candidates (`lsst.afw.math.SpatialCellSet`).
            ``characterized``
               Another reference to ``exposure`` for compatibility.
            ``backgroundModel``
               Another reference to ``background`` for compatibility.
 
        Raises
        ------
        RuntimeError
            Raised if PSF sigma is NaN.
        """
        self._frame = self._initialFrame  # reset debug display frame
 
        if not self.config.doMeasurePsf and not exposure.hasPsf():
            self.log.info("CharacterizeImageTask initialized with 'simple' PSF.")
            self.installSimplePsf.run(exposure=exposure)
 
        if idGenerator is None:
            idGenerator = IdGenerator()
 
        # subtract an initial estimate of background level
        background = self.background.run(exposure).background
 
        psfIterations = self.config.psfIterations if self.config.doMeasurePsf else 1
        for i in range(psfIterations):
            dmeRes = self.detectMeasureAndEstimatePsf(
                exposure=exposure,
                idGenerator=idGenerator,
                background=background,
            )
 
            psf = dmeRes.exposure.getPsf()
            # Just need a rough estimate; average positions are fine
            psfAvgPos = psf.getAveragePosition()
            psfSigma = psf.computeShape(psfAvgPos).getDeterminantRadius()
            psfDimensions = psf.computeImage(psfAvgPos).getDimensions()
            medBackground = np.median(dmeRes.background.getImage().getArray())
            self.log.info("iter %s; PSF sigma=%0.4f, dimensions=%s; median background=%0.2f",
                          i + 1, psfSigma, psfDimensions, medBackground)
            if np.isnan(psfSigma):
                raise RuntimeError("PSF sigma is NaN, cannot continue PSF determination.")
 
        self.display("psf", exposure=dmeRes.exposure, sourceCat=dmeRes.sourceCat)
 
        # perform final repair with final PSF
        self.repair.run(exposure=dmeRes.exposure)
        self.display("repair", exposure=dmeRes.exposure, sourceCat=dmeRes.sourceCat)
 
        # mask streaks
        if self.config.doMaskStreaks:
            _ = self.maskStreaks.run(dmeRes.exposure)
 
        # perform final measurement with final PSF, including measuring and applying aperture correction,
        # if wanted
        self.measurement.run(measCat=dmeRes.sourceCat, exposure=dmeRes.exposure,
                             exposureId=idGenerator.catalog_id)
        if self.config.doApCorr:
            try:
                apCorrMap = self.measureApCorr.run(
                    exposure=dmeRes.exposure,
                    catalog=dmeRes.sourceCat,
                ).apCorrMap
            except MeasureApCorrError:
                # We have failed to get a valid aperture correction map.
                # Proceed with processing, and image will be filtered
                # downstream.
                dmeRes.exposure.info.setApCorrMap(None)
            else:
                dmeRes.exposure.info.setApCorrMap(apCorrMap)
                self.applyApCorr.run(catalog=dmeRes.sourceCat, apCorrMap=exposure.getInfo().getApCorrMap())
 
        self.catalogCalculation.run(dmeRes.sourceCat)
 
        self.display("measure", exposure=dmeRes.exposure, sourceCat=dmeRes.sourceCat)
 
        return pipeBase.Struct(
            exposure=dmeRes.exposure,
            sourceCat=dmeRes.sourceCat,
            background=dmeRes.background,
            psfCellSet=dmeRes.psfCellSet,
 
            characterized=dmeRes.exposure,
            backgroundModel=dmeRes.background
        )
 

runQuantum()

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask.runQuantum	(		self,
			butlerQC,
			inputRefs,
			outputRefs )

Definition at line 336 of file characterizeImage.py.

    def runQuantum(self, butlerQC, inputRefs, outputRefs):
        inputs = butlerQC.get(inputRefs)
        if 'idGenerator' not in inputs.keys():
            inputs['idGenerator'] = self.config.idGenerator.apply(butlerQC.quantum.dataId)
        outputs = self.run(**inputs)
        butlerQC.put(outputs, outputRefs)
 

Member Data Documentation

_DefaultName

str lsst.pipe.tasks.characterizeImage.CharacterizeImageTask._DefaultName = "characterizeImage"

staticprotected

Definition at line 308 of file characterizeImage.py.

_frame

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask._frame

protected

Definition at line 332 of file characterizeImage.py.

_initialFrame

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask._initialFrame

protected

Definition at line 331 of file characterizeImage.py.

algMetadata

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask.algMetadata

Definition at line 322 of file characterizeImage.py.

ConfigClass

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask.ConfigClass = CharacterizeImageConfig

static

Definition at line 307 of file characterizeImage.py.

outputSchema

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask.outputSchema

Definition at line 334 of file characterizeImage.py.

schema

lsst.pipe.tasks.characterizeImage.CharacterizeImageTask.schema

Definition at line 315 of file characterizeImage.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/pipe_tasks/g2a9a014e59+6f9be1b9cd/python/lsst/pipe/tasks/characterizeImage.py