Inheritance diagram for lsst.meas.algorithms.noise_covariance.ComputeNoiseCorrelationTask:

Public Member Functions
	__init__ (self, args, *kwargs)

	subtractedBackground (self, lsst.afw.image.MaskedImage maskedImage)

CorrelationMatrix	run (self, lsst.afw.image.MaskedImage maskedImage, lsst.afw.image.MaskedImage\|None refMaskedImage=None)

Static Public Attributes
	ConfigClass = ComputeNoiseCorrelationConfig

Protected Member Functions
CorrelationMatrix	_pixelBased (self, lsst.afw.image.MaskedImage maskedImage, lsst.afw.image.MaskedImage refMaskedImage)

Static Protected Attributes
str	_DefaultName = "computeNoiseCorrelation"

Detailed Description

Compute the noise correlation coefficients 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 computes
a matrix of correlation coefficients of a desired size. It assumes that the
noise is (at least the correlation coefficients are) stationary and uses
spatial averaging to compute the correlation coefficients.

Definition at line 102 of file noise_covariance.py.

Constructor & Destructor Documentation

◆ init()

lsst.meas.algorithms.noise_covariance.ComputeNoiseCorrelationTask.__init__	(		self,
		*	args,
		**	kwargs )

Definition at line 116 of file noise_covariance.py.

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

Member Function Documentation

◆ _pixelBased()

CorrelationMatrix lsst.meas.algorithms.noise_covariance.ComputeNoiseCorrelationTask._pixelBased	(		self,
		lsst.afw.image.MaskedImage	maskedImage,
		lsst.afw.image.MaskedImage	refMaskedImage )

protected

Determine correlation coefficients between pixels

This is the concrete routine that does the computation.

Parameters
----------
maskedImage : `~lsst.afw.image.MaskedImage`
    Image for which to determine the variance rescaling factor.
refMaskedImage : `~lsst.afw.image.MaskedImage`
    Image from which to determine which pixels to mask.

Returns
-------
corr_matrix : `CorrelationMatrix`
    Correlation matrix of the maskedImage.

Definition at line 189 of file noise_covariance.py.

    ) -> CorrelationMatrix:
        """Determine correlation coefficients between pixels
 
        This is the concrete routine that does the computation.
 
        Parameters
        ----------
        maskedImage : `~lsst.afw.image.MaskedImage`
            Image for which to determine the variance rescaling factor.
        refMaskedImage : `~lsst.afw.image.MaskedImage`
            Image from which to determine which pixels to mask.
 
        Returns
        -------
        corr_matrix : `CorrelationMatrix`
            Correlation matrix of the maskedImage.
        """
        maskVal = refMaskedImage.mask.getPlaneBitMask(self.config.maskPlanes)
        isGood = (
            ((refMaskedImage.mask.array & maskVal) == 0)
            & np.isfinite(refMaskedImage.image.array)
            & np.isfinite(refMaskedImage.variance.array)
            & (refMaskedImage.variance.array > 0)
        )
 
        nGood = np.sum(isGood)
        self.log.debug(
            "Number of selected background pixels: %d of %d.", nGood, isGood.size
        )
 
        # Catch any RuntimeWarning that may arise by dividing by zero.
        # This is okay since we handle the zero variance case immediately.
        with warnings.catch_warnings():
            warnings.simplefilter("ignore", category=RuntimeWarning)
            normalized_arr = maskedImage.image.array / np.sqrt(
                maskedImage.variance.array
            )
        normalized_arr[~isGood] = np.nan
 
        corr_matrix = np.empty(
            (self.config.size + 1, self.config.size + 1), dtype=np.float32
        )
 
        for dx, dy in itertools.product(
            range(self.config.size + 1), range(self.config.size + 1)
        ):
            sliceX = slice(None, -dx) if dx != 0 else slice(None, None)
            sliceY = slice(None, -dy) if dy != 0 else slice(None, None)
            arr1 = normalized_arr[sliceX, sliceY]
 
            sliceX = slice(dx, None) if dx != 0 else slice(None, None)
            sliceY = slice(dy, None) if dy != 0 else slice(None, None)
            arr2 = normalized_arr[sliceX, sliceY]
 
            if self.config.subtractEmpiricalMean:
                arr1 -= np.nanmean(arr1)
                arr2 -= np.nanmean(arr2)
            if self.config.scaleEmpiricalVariance:
                # Do not use nanstd direct, as it will subtract the
                # empirical mean regardless of config set.
                arr1 /= np.nanmean(arr1**2) ** 0.5
                arr2 /= np.nanmean(arr2**2) ** 0.5
 
            cov = np.nanmean(arr1 * arr2)
            # Adjust for the bias in the estimator. Temporary reference:
            # https://en.wikipedia.org/wiki/Pearson_correlation_coefficient#Practical_issues
            # TODO: Explain this in the DMTN-215 (DM-33418).
            cov *= 1.0 + 0.5 * (1 - cov**2) / (~np.isnan(arr1 * arr2)).sum()
 
            corr_matrix[dx, dy] = cov
 
        return CorrelationMatrix(corr_matrix)

◆ run()

CorrelationMatrix lsst.meas.algorithms.noise_covariance.ComputeNoiseCorrelationTask.run	(		self,
		lsst.afw.image.MaskedImage	maskedImage,
		lsst.afw.image.MaskedImage \| None	refMaskedImage = None )

Compute the correlation matrix from a maskedImage.

Parameters
----------
maskedImage :  `~lsst.afw.image.MaskedImage`
    Image for which to determine the correlation matrix.
refMaskedImage : `~lsst.afw.image.MaskedImage`, optional
    Image from which to determine which pixels to mask.
    If None, it defaults to ``maskedImage``.

Returns
-------
corr_matrix : `CorrelationMatrix`
    Correlation matrix of the maskedImage.

Raises
------
RuntimeError
    Raised if ``refMaskedImage`` is provided and does not have the same
    dimensions as ``maskedImage``.

Definition at line 151 of file noise_covariance.py.

    ) -> CorrelationMatrix:
        """Compute the correlation matrix from a maskedImage.
 
        Parameters
        ----------
        maskedImage :  `~lsst.afw.image.MaskedImage`
            Image for which to determine the correlation matrix.
        refMaskedImage : `~lsst.afw.image.MaskedImage`, optional
            Image from which to determine which pixels to mask.
            If None, it defaults to ``maskedImage``.
 
        Returns
        -------
        corr_matrix : `CorrelationMatrix`
            Correlation matrix of the maskedImage.
 
        Raises
        ------
        RuntimeError
            Raised if ``refMaskedImage`` is provided and does not have the same
            dimensions as ``maskedImage``.
        """
        with self.subtractedBackground(maskedImage):
            if refMaskedImage is None:
                refMaskedImage = maskedImage
            elif refMaskedImage.getDimensions() != maskedImage.getDimensions():
                raise RuntimeError(
                    "Reference image has different dimensions than input image"
                )
 
            corr_matrix = self._pixelBased(maskedImage, refMaskedImage)
 
        return corr_matrix
 

◆ subtractedBackground()

lsst.meas.algorithms.noise_covariance.ComputeNoiseCorrelationTask.subtractedBackground	(		self,
		lsst.afw.image.MaskedImage	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 with unit variance.
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 122 of file noise_covariance.py.

    def subtractedBackground(self, maskedImage: lsst.afw.image.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 with unit variance.
        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
 

Member Data Documentation

◆ _DefaultName

str lsst.meas.algorithms.noise_covariance.ComputeNoiseCorrelationTask._DefaultName = "computeNoiseCorrelation"

staticprotected

Definition at line 114 of file noise_covariance.py.

◆ ConfigClass

lsst.meas.algorithms.noise_covariance.ComputeNoiseCorrelationTask.ConfigClass = ComputeNoiseCorrelationConfig

static

Definition at line 113 of file noise_covariance.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_algorithms/ge6526c86ff+3a7c1ac5f1/python/lsst/meas/algorithms/noise_covariance.py

Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Attributes