lsst.pipe.tasks.scaleVariance.ScaleVarianceTask Class Reference

Inheritance diagram for lsst.pipe.tasks.scaleVariance.ScaleVarianceTask:

Public Member Functions
def	__init__ (self, *args, **kwargs)
def	subtractedBackground (self, maskedImage)
def	run (self, maskedImage)
def	computeScaleFactors (self, maskedImage)
def	pixelBased (self, maskedImage)
def	imageBased (self, maskedImage)
def	emptyMetadata (self)
def	getSchemaCatalogs (self)
def	getAllSchemaCatalogs (self)
def	getFullMetadata (self)
def	getFullName (self)
def	getName (self)
def	getTaskDict (self)
def	makeSubtask (self, name, **keyArgs)
def	timer (self, name, logLevel=Log.DEBUG)
def	makeField (cls, doc)
def	__reduce__ (self)

Public Attributes
	metadata
	log
	config

Static Public Attributes
	ConfigClass = ScaleVarianceConfig

Detailed Description

Scale the variance in a MaskedImage

The variance plane in a convolved or warped image (or a coadd derived
from warped images) does not accurately reflect the noise properties of
the image because variance has been lost to covariance. This Task
attempts to correct for this by scaling the variance plane to match
the observed variance in the image. This is not perfect (because we're
not tracking the covariance) but it's simple and is often good enough.

The task implements a pixel-based and an image-based correction estimator.

Definition at line 48 of file scaleVariance.py.

Constructor & Destructor Documentation

__init__()

def lsst.pipe.tasks.scaleVariance.ScaleVarianceTask.__init__	(		self,
		*	args,
		**	kwargs
	)

Definition at line 63 of file scaleVariance.py.

    def __init__(self, *args, **kwargs):
        Task.__init__(self, *args, **kwargs)
        self.makeSubtask("background")
 

Member Function Documentation

__reduce__()

def lsst.pipe.base.task.Task.__reduce__ (   self )

inherited

Pickler.

Reimplemented in lsst.pipe.drivers.multiBandDriver.MultiBandDriverTask, and lsst.pipe.drivers.coaddDriver.CoaddDriverTask.

Definition at line 432 of file task.py.

    def __reduce__(self):
        """Pickler.
        """
        return self._unpickle_via_factory, (self.__class__, [], self._reduce_kwargs())

computeScaleFactors()

def lsst.pipe.tasks.scaleVariance.ScaleVarianceTask.computeScaleFactors	(		self,
			maskedImage
	)

Calculate and return both variance scaling factors without modifying the image.

Parameters
----------
maskedImage :  `lsst.afw.image.MaskedImage`
    Image for which to determine the variance rescaling factor.

Returns
-------
R : `lsst.pipe.base.Struct`
  - ``pixelFactor`` : `float` The pixel based variance rescaling factor
    or 1 if all pixels are masked or invalid.
  - ``imageFactor`` : `float` The image based variance rescaling factor
    or 1 if all pixels are masked or invalid.

Definition at line 135 of file scaleVariance.py.

    def computeScaleFactors(self, maskedImage):
        """Calculate and return both variance scaling factors without modifying the image.
 
        Parameters
        ----------
        maskedImage :  `lsst.afw.image.MaskedImage`
            Image for which to determine the variance rescaling factor.
 
        Returns
        -------
        R : `lsst.pipe.base.Struct`
          - ``pixelFactor`` : `float` The pixel based variance rescaling factor
            or 1 if all pixels are masked or invalid.
          - ``imageFactor`` : `float` The image based variance rescaling factor
            or 1 if all pixels are masked or invalid.
        """
        with self.subtractedBackground(maskedImage):
            pixelFactor = self.pixelBased(maskedImage)
            imageFactor = self.imageBased(maskedImage)
        return Struct(pixelFactor=pixelFactor, imageFactor=imageFactor)
 

emptyMetadata()

def lsst.pipe.base.task.Task.emptyMetadata (   self )

inherited

Empty (clear) the metadata for this Task and all sub-Tasks.

Definition at line 166 of file task.py.

    def emptyMetadata(self):
        """Empty (clear) the metadata for this Task and all sub-Tasks.
        """
        for subtask in self._taskDict.values():
            subtask.metadata = dafBase.PropertyList()
 

getAllSchemaCatalogs()

def lsst.pipe.base.task.Task.getAllSchemaCatalogs (   self )

inherited

Get schema catalogs for all tasks in the hierarchy, combining the
results into a single dict.

Returns
-------
schemacatalogs : `dict`
    Keys are butler dataset type, values are a empty catalog (an
    instance of the appropriate `lsst.afw.table` Catalog type) for all
    tasks in the hierarchy, from the top-level task down
    through all subtasks.

Notes
-----
This method may be called on any task in the hierarchy; it will return
the same answer, regardless.

The default implementation should always suffice. If your subtask uses
schemas the override `Task.getSchemaCatalogs`, not this method.

Definition at line 204 of file task.py.

    def getAllSchemaCatalogs(self):
        """Get schema catalogs for all tasks in the hierarchy, combining the
        results into a single dict.
 
        Returns
        -------
        schemacatalogs : `dict`
            Keys are butler dataset type, values are a empty catalog (an
            instance of the appropriate `lsst.afw.table` Catalog type) for all
            tasks in the hierarchy, from the top-level task down
            through all subtasks.
 
        Notes
        -----
        This method may be called on any task in the hierarchy; it will return
        the same answer, regardless.
 
        The default implementation should always suffice. If your subtask uses
        schemas the override `Task.getSchemaCatalogs`, not this method.
        """
        schemaDict = self.getSchemaCatalogs()
        for subtask in self._taskDict.values():
            schemaDict.update(subtask.getSchemaCatalogs())
        return schemaDict
 

getFullMetadata()

def lsst.pipe.base.task.Task.getFullMetadata (   self )

inherited

Get metadata for all tasks.

Returns
-------
metadata : `lsst.daf.base.PropertySet`
    The `~lsst.daf.base.PropertySet` keys are the full task name.
    Values are metadata for the top-level task and all subtasks,
    sub-subtasks, etc.

Notes
-----
The returned metadata includes timing information (if
``@timer.timeMethod`` is used) and any metadata set by the task. The
name of each item consists of the full task name with ``.`` replaced
by ``:``, followed by ``.`` and the name of the item, e.g.::

    topLevelTaskName:subtaskName:subsubtaskName.itemName

using ``:`` in the full task name disambiguates the rare situation
that a task has a subtask and a metadata item with the same name.

Definition at line 229 of file task.py.

    def getFullMetadata(self):
        """Get metadata for all tasks.
 
        Returns
        -------
        metadata : `lsst.daf.base.PropertySet`
            The `~lsst.daf.base.PropertySet` keys are the full task name.
            Values are metadata for the top-level task and all subtasks,
            sub-subtasks, etc.
 
        Notes
        -----
        The returned metadata includes timing information (if
        ``@timer.timeMethod`` is used) and any metadata set by the task. The
        name of each item consists of the full task name with ``.`` replaced
        by ``:``, followed by ``.`` and the name of the item, e.g.::
 
            topLevelTaskName:subtaskName:subsubtaskName.itemName
 
        using ``:`` in the full task name disambiguates the rare situation
        that a task has a subtask and a metadata item with the same name.
        """
        fullMetadata = dafBase.PropertySet()
        for fullName, task in self.getTaskDict().items():
            fullMetadata.set(fullName.replace(".", ":"), task.metadata)
        return fullMetadata
 

getFullName()

def lsst.pipe.base.task.Task.getFullName (   self )

inherited

Get the task name as a hierarchical name including parent task
names.

Returns
-------
fullName : `str`
    The full name consists of the name of the parent task and each
    subtask separated by periods. For example:

    - The full name of top-level task "top" is simply "top".
    - The full name of subtask "sub" of top-level task "top" is
      "top.sub".
    - The full name of subtask "sub2" of subtask "sub" of top-level
      task "top" is "top.sub.sub2".

Definition at line 256 of file task.py.

    def getFullName(self):
        """Get the task name as a hierarchical name including parent task
        names.
 
        Returns
        -------
        fullName : `str`
            The full name consists of the name of the parent task and each
            subtask separated by periods. For example:
 
            - The full name of top-level task "top" is simply "top".
            - The full name of subtask "sub" of top-level task "top" is
              "top.sub".
            - The full name of subtask "sub2" of subtask "sub" of top-level
              task "top" is "top.sub.sub2".
        """
        return self._fullName
 

getName()

def lsst.pipe.base.task.Task.getName (   self )

inherited

Get the name of the task.

Returns
-------
taskName : `str`
    Name of the task.

See also
--------
getFullName

Definition at line 274 of file task.py.

    def getName(self):
        """Get the name of the task.
 
        Returns
        -------
        taskName : `str`
            Name of the task.
 
        See also
        --------
        getFullName
        """
        return self._name
 

getSchemaCatalogs()

def lsst.pipe.base.task.Task.getSchemaCatalogs (   self )

inherited

Get the schemas generated by this task.

Returns
-------
schemaCatalogs : `dict`
    Keys are butler dataset type, values are an empty catalog (an
    instance of the appropriate `lsst.afw.table` Catalog type) for
    this task.

Notes
-----

.. warning::

   Subclasses that use schemas must override this method. The default
   implementation returns an empty dict.

This method may be called at any time after the Task is constructed,
which means that all task schemas should be computed at construction
time, *not* when data is actually processed. This reflects the
philosophy that the schema should not depend on the data.

Returning catalogs rather than just schemas allows us to save e.g.
slots for SourceCatalog as well.

See also
--------
Task.getAllSchemaCatalogs

Definition at line 172 of file task.py.

    def getSchemaCatalogs(self):
        """Get the schemas generated by this task.
 
        Returns
        -------
        schemaCatalogs : `dict`
            Keys are butler dataset type, values are an empty catalog (an
            instance of the appropriate `lsst.afw.table` Catalog type) for
            this task.
 
        Notes
        -----
 
        .. warning::
 
           Subclasses that use schemas must override this method. The default
           implementation returns an empty dict.
 
        This method may be called at any time after the Task is constructed,
        which means that all task schemas should be computed at construction
        time, *not* when data is actually processed. This reflects the
        philosophy that the schema should not depend on the data.
 
        Returning catalogs rather than just schemas allows us to save e.g.
        slots for SourceCatalog as well.
 
        See also
        --------
        Task.getAllSchemaCatalogs
        """
        return {}
 

getTaskDict()

def lsst.pipe.base.task.Task.getTaskDict (   self )

inherited

Get a dictionary of all tasks as a shallow copy.

Returns
-------
taskDict : `dict`
    Dictionary containing full task name: task object for the top-level
    task and all subtasks, sub-subtasks, etc.

Definition at line 288 of file task.py.

    def getTaskDict(self):
        """Get a dictionary of all tasks as a shallow copy.
 
        Returns
        -------
        taskDict : `dict`
            Dictionary containing full task name: task object for the top-level
            task and all subtasks, sub-subtasks, etc.
        """
        return self._taskDict.copy()
 

imageBased()

def lsst.pipe.tasks.scaleVariance.ScaleVarianceTask.imageBased	(		self,
			maskedImage
	)

Determine the variance rescaling factor from image statistics

We calculate average(SNR) = stdev(image)/median(variance), and
the value should be unity. We use the interquartile range as a robust
estimator of the stdev. The variance rescaling factor is the
factor that brings this value to unity.

This may not work well if the pixels from which we measure the
standard deviation of the image are not effectively the same pixels
from which we measure the median of the variance. In that case, use
an alternate method.

Parameters
----------
maskedImage :  `lsst.afw.image.MaskedImage`
    Image for which to determine the variance rescaling factor.

Returns
-------
factor : `float`
    Variance rescaling factor or 1 if all pixels are masked or non-finite.

Definition at line 198 of file scaleVariance.py.

    def imageBased(self, maskedImage):
        """Determine the variance rescaling factor from image statistics
 
        We calculate average(SNR) = stdev(image)/median(variance), and
        the value should be unity. We use the interquartile range as a robust
        estimator of the stdev. The variance rescaling factor is the
        factor that brings this value to unity.
 
        This may not work well if the pixels from which we measure the
        standard deviation of the image are not effectively the same pixels
        from which we measure the median of the variance. In that case, use
        an alternate method.
 
        Parameters
        ----------
        maskedImage :  `lsst.afw.image.MaskedImage`
            Image for which to determine the variance rescaling factor.
 
        Returns
        -------
        factor : `float`
            Variance rescaling factor or 1 if all pixels are masked or non-finite.
        """
        maskVal = maskedImage.mask.getPlaneBitMask(self.config.maskPlanes)
        isGood = (((maskedImage.mask.array & maskVal) == 0)
                  & np.isfinite(maskedImage.image.array)
                  & np.isfinite(maskedImage.variance.array)
                  & (maskedImage.variance.array > 0))
        nGood = np.sum(isGood)
        self.log.debugf("Number of selected background pixels: {} of {}.", nGood, isGood.size)
        if nGood < 2:
            # Not enough good data, np.percentile needs at least 2 points
            # to estimate a range
            return 1.0
        # Robust measurement of stdev
        q1, q3 = np.percentile(maskedImage.image.array[isGood], (25, 75))
        ratio = 0.74*(q3 - q1)/np.sqrt(np.median(maskedImage.variance.array[isGood]))
        return ratio**2

makeField()

def lsst.pipe.base.task.Task.makeField (   cls,   doc  )

inherited

Make a `lsst.pex.config.ConfigurableField` for this task.

Parameters
----------
doc : `str`
    Help text for the field.

Returns
-------
configurableField : `lsst.pex.config.ConfigurableField`
    A `~ConfigurableField` for this task.

Examples
--------
Provides a convenient way to specify this task is a subtask of another
task.

Here is an example of use:

.. code-block:: python

    class OtherTaskConfig(lsst.pex.config.Config):
        aSubtask = ATaskClass.makeField("brief description of task")

Definition at line 359 of file task.py.

    def makeField(cls, doc):
        """Make a `lsst.pex.config.ConfigurableField` for this task.
 
        Parameters
        ----------
        doc : `str`
            Help text for the field.
 
        Returns
        -------
        configurableField : `lsst.pex.config.ConfigurableField`
            A `~ConfigurableField` for this task.
 
        Examples
        --------
        Provides a convenient way to specify this task is a subtask of another
        task.
 
        Here is an example of use:
 
        .. code-block:: python
 
            class OtherTaskConfig(lsst.pex.config.Config):
                aSubtask = ATaskClass.makeField("brief description of task")
        """
        return ConfigurableField(doc=doc, target=cls)
 

makeSubtask()

def lsst.pipe.base.task.Task.makeSubtask (   self,   name, **  keyArgs  )

inherited

Create a subtask as a new instance as the ``name`` attribute of this
task.

Parameters
----------
name : `str`
    Brief name of the subtask.
keyArgs
    Extra keyword arguments used to construct the task. The following
    arguments are automatically provided and cannot be overridden:

    - "config".
    - "parentTask".

Notes
-----
The subtask must be defined by ``Task.config.name``, an instance of
`~lsst.pex.config.ConfigurableField` or
`~lsst.pex.config.RegistryField`.

Definition at line 299 of file task.py.

    def makeSubtask(self, name, **keyArgs):
        """Create a subtask as a new instance as the ``name`` attribute of this
        task.
 
        Parameters
        ----------
        name : `str`
            Brief name of the subtask.
        keyArgs
            Extra keyword arguments used to construct the task. The following
            arguments are automatically provided and cannot be overridden:
 
            - "config".
            - "parentTask".
 
        Notes
        -----
        The subtask must be defined by ``Task.config.name``, an instance of
        `~lsst.pex.config.ConfigurableField` or
        `~lsst.pex.config.RegistryField`.
        """
        taskField = getattr(self.config, name, None)
        if taskField is None:
            raise KeyError(f"{self.getFullName()}'s config does not have field {name!r}")
        subtask = taskField.apply(name=name, parentTask=self, **keyArgs)
        setattr(self, name, subtask)
 

pixelBased()

def lsst.pipe.tasks.scaleVariance.ScaleVarianceTask.pixelBased	(		self,
			maskedImage
	)

Determine the variance rescaling factor from pixel statistics

We calculate SNR = image/sqrt(variance), and the distribution
for most of the background-subtracted image should have a standard
deviation of unity. We use the interquartile range as a robust estimator
of the SNR standard deviation. The variance rescaling factor is the
factor that brings that distribution to have unit standard deviation.

This may not work well if the image has a lot of structure in it, as
the assumptions are violated. In that case, use an alternate
method.

Parameters
----------
maskedImage : `lsst.afw.image.MaskedImage`
    Image for which to determine the variance rescaling factor.

Returns
-------
factor : `float`
    Variance rescaling factor or 1 if all pixels are masked or non-finite.

Definition at line 156 of file scaleVariance.py.

    def pixelBased(self, maskedImage):
        """Determine the variance rescaling factor from pixel statistics
 
        We calculate SNR = image/sqrt(variance), and the distribution
        for most of the background-subtracted image should have a standard
        deviation of unity. We use the interquartile range as a robust estimator
        of the SNR standard deviation. The variance rescaling factor is the
        factor that brings that distribution to have unit standard deviation.
 
        This may not work well if the image has a lot of structure in it, as
        the assumptions are violated. In that case, use an alternate
        method.
 
        Parameters
        ----------
        maskedImage : `lsst.afw.image.MaskedImage`
            Image for which to determine the variance rescaling factor.
 
        Returns
        -------
        factor : `float`
            Variance rescaling factor or 1 if all pixels are masked or non-finite.
 
        """
        maskVal = maskedImage.mask.getPlaneBitMask(self.config.maskPlanes)
        isGood = (((maskedImage.mask.array & maskVal) == 0)
                  & np.isfinite(maskedImage.image.array)
                  & np.isfinite(maskedImage.variance.array)
                  & (maskedImage.variance.array > 0))
 
        nGood = np.sum(isGood)
        self.log.debugf("Number of selected background pixels: {} of {}.", nGood, isGood.size)
        if nGood < 2:
            # Not enough good data, np.percentile needs at least 2 points
            # to estimate a range
            return 1.0
        # Robust measurement of stdev using inter-quartile range
        snr = maskedImage.image.array[isGood]/np.sqrt(maskedImage.variance.array[isGood])
        q1, q3 = np.percentile(snr, (25, 75))
        stdev = 0.74*(q3 - q1)
        return stdev**2
 

run()

def lsst.pipe.tasks.scaleVariance.ScaleVarianceTask.run	(		self,
			maskedImage
	)

Rescale the variance in a maskedImage in place.

Parameters
----------
maskedImage :  `lsst.afw.image.MaskedImage`
    Image for which to determine the variance rescaling factor. The image
    is modified in place.

Returns
-------
factor : `float`
    Variance rescaling factor.

Raises
------
RuntimeError
    If the estimated variance rescaling factor by both methods exceed the
    configured limit.

Notes
-----
The task calculates and applies the pixel-based correction unless
it is over the ``config.limit`` threshold. In this case, the image-based
method is applied.

Definition at line 96 of file scaleVariance.py.

    def run(self, maskedImage):
        """Rescale the variance in a maskedImage in place.
 
        Parameters
        ----------
        maskedImage :  `lsst.afw.image.MaskedImage`
            Image for which to determine the variance rescaling factor. The image
            is modified in place.
 
        Returns
        -------
        factor : `float`
            Variance rescaling factor.
 
        Raises
        ------
        RuntimeError
            If the estimated variance rescaling factor by both methods exceed the
            configured limit.
 
        Notes
        -----
        The task calculates and applies the pixel-based correction unless
        it is over the ``config.limit`` threshold. In this case, the image-based
        method is applied.
        """
        with self.subtractedBackground(maskedImage):
            factor = self.pixelBased(maskedImage)
            if factor > self.config.limit:
                self.log.warn("Pixel-based variance rescaling factor (%f) exceeds configured limit (%f); "
                              "trying image-based method", factor, self.config.limit)
                factor = self.imageBased(maskedImage)
                if factor > self.config.limit:
                    raise RuntimeError("Variance rescaling factor (%f) exceeds configured limit (%f)" %
                                       (factor, self.config.limit))
            self.log.info("Renormalizing variance by %f" % (factor,))
            maskedImage.variance *= factor
        return factor
 

subtractedBackground()

def lsst.pipe.tasks.scaleVariance.ScaleVarianceTask.subtractedBackground	(		self,
			maskedImage
	)

Context manager for subtracting the background

We need to subtract the background so that the entire image
(apart from objects, which should be clipped) will have the
image/sqrt(variance) distributed about zero.

This context manager subtracts the background, and ensures it
is restored on exit.

Parameters
----------
maskedImage : `lsst.afw.image.MaskedImage`
    Image+mask+variance to have background subtracted and restored.

Returns
-------
context : context manager
    Context manager that ensure the background is restored.

Definition at line 68 of file scaleVariance.py.

    def subtractedBackground(self, maskedImage):
        """Context manager for subtracting the background
 
        We need to subtract the background so that the entire image
        (apart from objects, which should be clipped) will have the
        image/sqrt(variance) distributed about zero.
 
        This context manager subtracts the background, and ensures it
        is restored on exit.
 
        Parameters
        ----------
        maskedImage : `lsst.afw.image.MaskedImage`
            Image+mask+variance to have background subtracted and restored.
 
        Returns
        -------
        context : context manager
            Context manager that ensure the background is restored.
        """
        bg = self.background.fitBackground(maskedImage)
        bgImage = bg.getImageF(self.background.config.algorithm, self.background.config.undersampleStyle)
        maskedImage -= bgImage
        try:
            yield
        finally:
            maskedImage += bgImage
 

timer()

def lsst.pipe.base.task.Task.timer (   self,   name,   logLevel = Log.DEBUG  )

inherited

Context manager to log performance data for an arbitrary block of
code.

Parameters
----------
name : `str`
    Name of code being timed; data will be logged using item name:
    ``Start`` and ``End``.
logLevel
    A `lsst.log` level constant.

Examples
--------
Creating a timer context:

.. code-block:: python

    with self.timer("someCodeToTime"):
        pass  # code to time

See also
--------
timer.logInfo

Definition at line 327 of file task.py.

    def timer(self, name, logLevel=Log.DEBUG):
        """Context manager to log performance data for an arbitrary block of
        code.
 
        Parameters
        ----------
        name : `str`
            Name of code being timed; data will be logged using item name:
            ``Start`` and ``End``.
        logLevel
            A `lsst.log` level constant.
 
        Examples
        --------
        Creating a timer context:
 
        .. code-block:: python
 
            with self.timer("someCodeToTime"):
                pass  # code to time
 
        See also
        --------
        timer.logInfo
        """
        logInfo(obj=self, prefix=name + "Start", logLevel=logLevel)
        try:
            yield
        finally:
            logInfo(obj=self, prefix=name + "End", logLevel=logLevel)
 

Member Data Documentation

config

lsst.pipe.base.task.Task.config

inherited

Definition at line 162 of file task.py.

ConfigClass

lsst.pipe.tasks.scaleVariance.ScaleVarianceTask.ConfigClass = ScaleVarianceConfig

static

Definition at line 60 of file scaleVariance.py.

log

lsst.pipe.base.task.Task.log

inherited

Definition at line 161 of file task.py.

metadata

lsst.pipe.base.task.Task.metadata

inherited

Definition at line 134 of file task.py.

---

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

• /j/snowflake/release/lsstsw/stack/0.4.3/Linux64/pipe_tasks/21.0.0-64-g1122c245+4fb2b8f86e/python/lsst/pipe/tasks/scaleVariance.py