Inheritance diagram for lsst.ip.isr.overscan.OverscanCorrectionTask:

Public Member Functions
def	__init__ (self, statControl=None, **kwargs)

def	run (self, ampImage, overscanImage, amp=None)

def	measureConstantOverscan (self, image)

def	getImageArray (self, image)

def	maskOutliers (self, imageArray)

def	collapseArrayMedian (self, maskedArray)

def	splineFit (self, indices, collapsed, numBins)

def	measureVectorOverscan (self, image)

def	debugView (self, image, model, amp=None)

Static Public Member Functions
def	integerConvert (image)

def	transpose (imageArray)

def	collapseArray (maskedArray)

def	splineEval (indices, interp)

def	maskExtrapolated (collapsed)

Public Attributes
	allowDebug

	statControl

Static Public Attributes
	ConfigClass = OverscanCorrectionTaskConfig

Detailed Description

Correction task for overscan.

This class contains a number of utilities that are easier to
understand and use when they are not embedded in nested if/else
loops.

Parameters
----------
statControl : `lsst.afw.math.StatisticsControl`, optional
    Statistics control object.

Definition at line 75 of file overscan.py.

Constructor & Destructor Documentation

◆ init()

def lsst.ip.isr.overscan.OverscanCorrectionTask.__init__	(		self,
			statControl = `None`,
		**	kwargs
	)

Definition at line 90 of file overscan.py.

     def __init__(self, statControl=None, **kwargs):
         super().__init__(**kwargs)
         self.allowDebug = True
  
         if statControl:
             self.statControl = statControl
         else:
             self.statControl = afwMath.StatisticsControl()
             self.statControl.setNumSigmaClip(self.config.numSigmaClip)
             self.statControl.setAndMask(afwImage.Mask.getPlaneBitMask(self.config.maskPlanes))
  

Member Function Documentation

◆ collapseArray()

def lsst.ip.isr.overscan.OverscanCorrectionTask.collapseArray ( maskedArray )

static

Collapse overscan array (and mask) to a 1-D vector of values.

Parameters
----------
maskedArray : `numpy.ma.masked_array`
    Masked array of input overscan data.

Returns
-------
collapsed : `numpy.ma.masked_array`
    Single dimensional overscan data, combined with the mean.

Definition at line 311 of file overscan.py.

     def collapseArray(maskedArray):
         """Collapse overscan array (and mask) to a 1-D vector of values.
  
         Parameters
         ----------
         maskedArray : `numpy.ma.masked_array`
             Masked array of input overscan data.
  
         Returns
         -------
         collapsed : `numpy.ma.masked_array`
             Single dimensional overscan data, combined with the mean.
         """
         collapsed = np.mean(maskedArray, axis=1)
         if collapsed.mask.sum() > 0:
             collapsed.data[collapsed.mask] = np.mean(maskedArray.data[collapsed.mask], axis=1)
         return collapsed
  

◆ collapseArrayMedian()

def lsst.ip.isr.overscan.OverscanCorrectionTask.collapseArrayMedian	(	self,
		maskedArray
	)

Collapse overscan array (and mask) to a 1-D vector of using the
correct integer median of row-values.

Parameters
----------
maskedArray : `numpy.ma.masked_array`
    Masked array of input overscan data.

Returns
-------
collapsed : `numpy.ma.masked_array`
    Single dimensional overscan data, combined with the afwMath median.

Definition at line 329 of file overscan.py.

     def collapseArrayMedian(self, maskedArray):
         """Collapse overscan array (and mask) to a 1-D vector of using the
         correct integer median of row-values.
  
         Parameters
         ----------
         maskedArray : `numpy.ma.masked_array`
             Masked array of input overscan data.
  
         Returns
         -------
         collapsed : `numpy.ma.masked_array`
             Single dimensional overscan data, combined with the afwMath median.
         """
         integerMI = self.integerConvert(maskedArray)
  
         collapsed = []
         fitType = afwMath.stringToStatisticsProperty('MEDIAN')
         for row in integerMI:
             newRow = row.compressed()
             if len(newRow) > 0:
                 rowMedian = afwMath.makeStatistics(newRow, fitType, self.statControl).getValue()
             else:
                 rowMedian = np.nan
             collapsed.append(rowMedian)
  
         return np.array(collapsed)
  

◆ debugView()

def lsst.ip.isr.overscan.OverscanCorrectionTask.debugView	(	self,
		image,
		model,
		amp = `None`
	)

Debug display for the final overscan solution.

Parameters
----------
image : `lsst.afw.image.Image`
    Input image the overscan solution was determined from.
model : `numpy.ndarray` or `float`
    Overscan model determined for the image.
amp : `lsst.afw.cameraGeom.Amplifier`, optional
    Amplifier to extract diagnostic information.

Definition at line 491 of file overscan.py.

     def debugView(self, image, model, amp=None):
         """Debug display for the final overscan solution.
  
         Parameters
         ----------
         image : `lsst.afw.image.Image`
             Input image the overscan solution was determined from.
         model : `numpy.ndarray` or `float`
             Overscan model determined for the image.
         amp : `lsst.afw.cameraGeom.Amplifier`, optional
             Amplifier to extract diagnostic information.
         """
         import lsstDebug
         if not lsstDebug.Info(__name__).display:
             return
         if not self.allowDebug:
             return
  
         calcImage = self.getImageArray(image)
         calcImage, isTransposed = self.transpose(calcImage)
         masked = self.maskOutliers(calcImage)
         collapsed = self.collapseArray(masked)
  
         num = len(collapsed)
         indices = 2.0 * np.arange(num)/float(num) - 1.0
  
         if np.ma.is_masked(collapsed):
             collapsedMask = collapsed.mask
         else:
             collapsedMask = np.array(num*[np.ma.nomask])
  
         import matplotlib.pyplot as plot
         figure = plot.figure(1)
         figure.clear()
         axes = figure.add_axes((0.1, 0.1, 0.8, 0.8))
         axes.plot(indices[~collapsedMask], collapsed[~collapsedMask], 'k+')
         if collapsedMask.sum() > 0:
             axes.plot(indices[collapsedMask], collapsed.data[collapsedMask], 'b+')
         if isinstance(model, np.ndarray):
             plotModel = model
         else:
             plotModel = np.zeros_like(indices)
             plotModel += model
         axes.plot(indices, plotModel, 'r-')
         plot.xlabel("centered/scaled position along overscan region")
         plot.ylabel("pixel value/fit value")
         if amp:
             plot.title(f"{amp.getName()} DataX: "
                        f"[{amp.getRawDataBBox().getBeginX()}:{amp.getRawBBox().getEndX()}]"
                        f"OscanX: [{amp.getRawHorizontalOverscanBBox().getBeginX()}:"
                        f"{amp.getRawHorizontalOverscanBBox().getEndX()}] {self.config.fitType}")
         else:
             plot.title("No amp supplied.")
         figure.show()
         prompt = "Press Enter or c to continue [chp]..."
         while True:
             ans = input(prompt).lower()
             if ans in ("", " ", "c",):
                 break
             elif ans in ("p", ):
                 import pdb
                 pdb.set_trace()
             elif ans in ('x', ):
                 self.allowDebug = False
                 break
             elif ans in ("h", ):
                 print("[h]elp [c]ontinue [p]db e[x]itDebug")
         plot.close()

◆ getImageArray()

def lsst.ip.isr.overscan.OverscanCorrectionTask.getImageArray	(	self,
		image
	)

Extract the numpy array from the input image.

Parameters
----------
image : `lsst.afw.image.Image` or `lsst.afw.image.MaskedImage`
    Image data to pull array from.

calcImage : `numpy.ndarray`
    Image data array for numpy operating.

Definition at line 248 of file overscan.py.

     def getImageArray(self, image):
         """Extract the numpy array from the input image.
  
         Parameters
         ----------
         image : `lsst.afw.image.Image` or `lsst.afw.image.MaskedImage`
             Image data to pull array from.
  
         calcImage : `numpy.ndarray`
             Image data array for numpy operating.
         """
         if hasattr(image, "getImage"):
             calcImage = image.getImage().getArray()
             calcImage = np.ma.masked_where(image.getMask().getArray() & self.statControl.getAndMask(),
                                            calcImage)
         else:
             calcImage = image.getArray()
         return calcImage
  

◆ integerConvert()

def lsst.ip.isr.overscan.OverscanCorrectionTask.integerConvert ( image )

static

Return an integer version of the input image.

Parameters
----------
image : `numpy.ndarray`, `lsst.afw.image.Image` or `MaskedImage`
    Image to convert to integers.

Returns
-------
outI : `numpy.ndarray`, `lsst.afw.image.Image` or `MaskedImage`
    The integer converted image.

Raises
------
RuntimeError
    Raised if the input image could not be converted.

Definition at line 185 of file overscan.py.

     def integerConvert(image):
         """Return an integer version of the input image.
  
         Parameters
         ----------
         image : `numpy.ndarray`, `lsst.afw.image.Image` or `MaskedImage`
             Image to convert to integers.
  
         Returns
         -------
         outI : `numpy.ndarray`, `lsst.afw.image.Image` or `MaskedImage`
             The integer converted image.
  
         Raises
         ------
         RuntimeError
             Raised if the input image could not be converted.
         """
         if hasattr(image, "image"):
             # Is a maskedImage:
             imageI = image.image.convertI()
             outI = afwImage.MaskedImageI(imageI, image.mask, image.variance)
         elif hasattr(image, "convertI"):
             # Is an Image:
             outI = image.convertI()
         elif hasattr(image, "astype"):
             # Is a numpy array:
             outI = image.astype(int)
         else:
             raise RuntimeError("Could not convert this to integers: %s %s %s",
                                image, type(image), dir(image))
         return outI
  

◆ maskExtrapolated()

def lsst.ip.isr.overscan.OverscanCorrectionTask.maskExtrapolated ( collapsed )

static

Create mask if edges are extrapolated.

Parameters
----------
collapsed : `numpy.ma.masked_array`
    Masked array to check the edges of.

Returns
-------
maskArray : `numpy.ndarray`
    Boolean numpy array of pixels to mask.

Definition at line 410 of file overscan.py.

     def maskExtrapolated(collapsed):
         """Create mask if edges are extrapolated.
  
         Parameters
         ----------
         collapsed : `numpy.ma.masked_array`
             Masked array to check the edges of.
  
         Returns
         -------
         maskArray : `numpy.ndarray`
             Boolean numpy array of pixels to mask.
         """
         maskArray = np.full_like(collapsed, False, dtype=bool)
         if np.ma.is_masked(collapsed):
             num = len(collapsed)
             for low in range(num):
                 if not collapsed.mask[low]:
                     break
             if low > 0:
                 maskArray[:low] = True
             for high in range(1, num):
                 if not collapsed.mask[-high]:
                     break
             if high > 1:
                 maskArray[-high:] = True
         return maskArray
  

◆ maskOutliers()

def lsst.ip.isr.overscan.OverscanCorrectionTask.maskOutliers	(	self,
		imageArray
	)

Mask  outliers in  a  row  of overscan  data  from  a robust  sigma
clipping procedure.

Parameters
----------
imageArray : `numpy.ndarray`
    Image to filter along numpy axis=1.

Returns
-------
maskedArray : `numpy.ma.masked_array`
    Masked image marking outliers.

Definition at line 288 of file overscan.py.

     def maskOutliers(self, imageArray):
         """Mask  outliers in  a  row  of overscan  data  from  a robust  sigma
         clipping procedure.
  
         Parameters
         ----------
         imageArray : `numpy.ndarray`
             Image to filter along numpy axis=1.
  
         Returns
         -------
         maskedArray : `numpy.ma.masked_array`
             Masked image marking outliers.
         """
         lq, median, uq = np.percentile(imageArray, [25.0, 50.0, 75.0], axis=1)
         axisMedians = median
         axisStdev = 0.74*(uq - lq)  # robust stdev
  
         diff = np.abs(imageArray - axisMedians[:, np.newaxis])
         return np.ma.masked_where(diff > self.statControl.getNumSigmaClip()
                                   * axisStdev[:, np.newaxis], imageArray)
  

◆ measureConstantOverscan()

def lsst.ip.isr.overscan.OverscanCorrectionTask.measureConstantOverscan	(	self,
		image
	)

Measure a constant overscan value.

Parameters
----------
image : `lsst.afw.image.Image` or `lsst.afw.image.MaskedImage`
    Image data to measure the overscan from.

Returns
-------
results : `lsst.pipe.base.Struct`
    Overscan result with entries:
    - ``overscanValue``: Overscan value to subtract (`float`)
    - ``maskArray``: Placeholder for a mask array (`list`)
    - ``isTransposed``: Orientation of the overscan (`bool`)

Definition at line 219 of file overscan.py.

     def measureConstantOverscan(self, image):
         """Measure a constant overscan value.
  
         Parameters
         ----------
         image : `lsst.afw.image.Image` or `lsst.afw.image.MaskedImage`
             Image data to measure the overscan from.
  
         Returns
         -------
         results : `lsst.pipe.base.Struct`
             Overscan result with entries:
             - ``overscanValue``: Overscan value to subtract (`float`)
             - ``maskArray``: Placeholder for a mask array (`list`)
             - ``isTransposed``: Orientation of the overscan (`bool`)
         """
         if self.config.fitType == 'MEDIAN':
             calcImage = self.integerConvert(image)
         else:
             calcImage = image
  
         fitType = afwMath.stringToStatisticsProperty(self.config.fitType)
         overscanValue = afwMath.makeStatistics(calcImage, fitType, self.statControl).getValue()
  
         return pipeBase.Struct(overscanValue=overscanValue,
                                maskArray=None,
                                isTransposed=False)
  

◆ measureVectorOverscan()

def lsst.ip.isr.overscan.OverscanCorrectionTask.measureVectorOverscan	(	self,
		image
	)

Calculate the 1-d vector overscan from the input overscan image.

Parameters
----------
image : `lsst.afw.image.MaskedImage`
    Image containing the overscan data.

Returns
-------
results : `lsst.pipe.base.Struct`
    Overscan result with entries:
    - ``overscanValue``: Overscan value to subtract (`float`)
    - ``maskArray`` : `list` [ `bool` ]
        List of rows that should be masked as ``SUSPECT`` when the
        overscan solution is applied.
    - ``isTransposed`` : `bool`
       Indicates if the overscan data was transposed during
       calcuation, noting along which axis the overscan should be
       subtracted.

Definition at line 438 of file overscan.py.

     def measureVectorOverscan(self, image):
         """Calculate the 1-d vector overscan from the input overscan image.
  
         Parameters
         ----------
         image : `lsst.afw.image.MaskedImage`
             Image containing the overscan data.
  
         Returns
         -------
         results : `lsst.pipe.base.Struct`
             Overscan result with entries:
             - ``overscanValue``: Overscan value to subtract (`float`)
             - ``maskArray`` : `list` [ `bool` ]
                 List of rows that should be masked as ``SUSPECT`` when the
                 overscan solution is applied.
             - ``isTransposed`` : `bool`
                Indicates if the overscan data was transposed during
                calcuation, noting along which axis the overscan should be
                subtracted.
         """
         calcImage = self.getImageArray(image)
  
         # operate on numpy-arrays from here
         calcImage, isTransposed = self.transpose(calcImage)
         masked = self.maskOutliers(calcImage)
  
         if self.config.fitType == 'MEDIAN_PER_ROW':
             overscanVector = self.collapseArrayMedian(masked)
             maskArray = self.maskExtrapolated(overscanVector)
         else:
             collapsed = self.collapseArray(masked)
  
             num = len(collapsed)
             indices = 2.0*np.arange(num)/float(num) - 1.0
  
             poly = np.polynomial
             fitter, evaler = {
                 'POLY': (poly.polynomial.polyfit, poly.polynomial.polyval),
                 'CHEB': (poly.chebyshev.chebfit, poly.chebyshev.chebval),
                 'LEG': (poly.legendre.legfit, poly.legendre.legval),
                 'NATURAL_SPLINE': (self.splineFit, self.splineEval),
                 'CUBIC_SPLINE': (self.splineFit, self.splineEval),
                 'AKIMA_SPLINE': (self.splineFit, self.splineEval)
             }[self.config.fitType]
  
             coeffs = fitter(indices, collapsed, self.config.order)
             overscanVector = evaler(indices, coeffs)
             maskArray = self.maskExtrapolated(collapsed)
         return pipeBase.Struct(overscanValue=np.array(overscanVector),
                                maskArray=maskArray,
                                isTransposed=isTransposed)
  

◆ run()

def lsst.ip.isr.overscan.OverscanCorrectionTask.run	(	self,
		ampImage,
		overscanImage,
		amp = `None`
	)

Measure and remove an overscan from an amplifier image.

Parameters
----------
ampImage : `lsst.afw.image.Image`
    Image data that will have the overscan removed.
overscanImage : `lsst.afw.image.Image`
    Overscan data that the overscan is measured from.
amp : `lsst.afw.cameraGeom.Amplifier`, optional
    Amplifier to use for debugging purposes.

Returns
-------
overscanResults : `lsst.pipe.base.Struct`
    Result struct with components:

    ``imageFit``
        Value or fit subtracted from the amplifier image data
        (scalar or `lsst.afw.image.Image`).
    ``overscanFit``
        Value or fit subtracted from the overscan image data
        (scalar or `lsst.afw.image.Image`).
    ``overscanImage``
        Image of the overscan region with the overscan
        correction applied (`lsst.afw.image.Image`). This
        quantity is used to estimate the amplifier read noise
        empirically.

Raises
------
RuntimeError
    Raised if an invalid overscan type is set.

Definition at line 101 of file overscan.py.

     def run(self, ampImage, overscanImage, amp=None):
         """Measure and remove an overscan from an amplifier image.
  
         Parameters
         ----------
         ampImage : `lsst.afw.image.Image`
             Image data that will have the overscan removed.
         overscanImage : `lsst.afw.image.Image`
             Overscan data that the overscan is measured from.
         amp : `lsst.afw.cameraGeom.Amplifier`, optional
             Amplifier to use for debugging purposes.
  
         Returns
         -------
         overscanResults : `lsst.pipe.base.Struct`
             Result struct with components:
  
             ``imageFit``
                 Value or fit subtracted from the amplifier image data
                 (scalar or `lsst.afw.image.Image`).
             ``overscanFit``
                 Value or fit subtracted from the overscan image data
                 (scalar or `lsst.afw.image.Image`).
             ``overscanImage``
                 Image of the overscan region with the overscan
                 correction applied (`lsst.afw.image.Image`). This
                 quantity is used to estimate the amplifier read noise
                 empirically.
  
         Raises
         ------
         RuntimeError
             Raised if an invalid overscan type is set.
  
         """
         if self.config.fitType in ('MEAN', 'MEANCLIP', 'MEDIAN'):
             overscanResult = self.measureConstantOverscan(overscanImage)
             overscanValue = overscanResult.overscanValue
             offImage = overscanValue
             overscanModel = overscanValue
             maskSuspect = None
         elif self.config.fitType in ('MEDIAN_PER_ROW', 'POLY', 'CHEB', 'LEG',
                                      'NATURAL_SPLINE', 'CUBIC_SPLINE', 'AKIMA_SPLINE'):
             overscanResult = self.measureVectorOverscan(overscanImage)
             overscanValue = overscanResult.overscanValue
             maskArray = overscanResult.maskArray
             isTransposed = overscanResult.isTransposed
  
             offImage = afwImage.ImageF(ampImage.getDimensions())
             offArray = offImage.getArray()
             overscanModel = afwImage.ImageF(overscanImage.getDimensions())
             overscanArray = overscanModel.getArray()
  
             if hasattr(ampImage, 'getMask'):
                 maskSuspect = afwImage.Mask(ampImage.getDimensions())
             else:
                 maskSuspect = None
  
             if isTransposed:
                 offArray[:, :] = overscanValue[np.newaxis, :]
                 overscanArray[:, :] = overscanValue[np.newaxis, :]
                 if maskSuspect:
                     maskSuspect.getArray()[:, maskArray] |= ampImage.getMask().getPlaneBitMask("SUSPECT")
             else:
                 offArray[:, :] = overscanValue[:, np.newaxis]
                 overscanArray[:, :] = overscanValue[:, np.newaxis]
                 if maskSuspect:
                     maskSuspect.getArray()[maskArray, :] |= ampImage.getMask().getPlaneBitMask("SUSPECT")
         else:
             raise RuntimeError('%s : %s an invalid overscan type' %
                                ("overscanCorrection", self.config.fitType))
  
         self.debugView(overscanImage, overscanValue, amp)
  
         ampImage -= offImage
         if maskSuspect:
             ampImage.getMask().getArray()[:, :] |= maskSuspect.getArray()[:, :]
         overscanImage -= overscanModel
         return pipeBase.Struct(imageFit=offImage,
                                overscanFit=overscanModel,
                                overscanImage=overscanImage,
                                edgeMask=maskSuspect)
  

◆ splineEval()

def lsst.ip.isr.overscan.OverscanCorrectionTask.splineEval	(	indices,
		interp
	)

static

Wrapper function to match spline evaluation API to polynomial fit API.

Parameters
----------
indices : `numpy.ndarray`
    Locations to evaluate the spline.
interp : `lsst.afw.math.interpolate`
    Interpolation object to use.

Returns
-------
values : `numpy.ndarray`
    Evaluated spline values at each index.

Definition at line 391 of file overscan.py.

     def splineEval(indices, interp):
         """Wrapper function to match spline evaluation API to polynomial fit API.
  
         Parameters
         ----------
         indices : `numpy.ndarray`
             Locations to evaluate the spline.
         interp : `lsst.afw.math.interpolate`
             Interpolation object to use.
  
         Returns
         -------
         values : `numpy.ndarray`
             Evaluated spline values at each index.
         """
  
         return interp.interpolate(indices.astype(float))
  

◆ splineFit()

def lsst.ip.isr.overscan.OverscanCorrectionTask.splineFit	(	self,
		indices,
		collapsed,
		numBins
	)

Wrapper function to match spline fit API to polynomial fit API.

Parameters
----------
indices : `numpy.ndarray`
    Locations to evaluate the spline.
collapsed : `numpy.ndarray`
    Collapsed overscan values corresponding to the spline
    evaluation points.
numBins : `int`
    Number of bins to use in constructing the spline.

Returns
-------
interp : `lsst.afw.math.Interpolate`
    Interpolation object for later evaluation.

Definition at line 357 of file overscan.py.

     def splineFit(self, indices, collapsed, numBins):
         """Wrapper function to match spline fit API to polynomial fit API.
  
         Parameters
         ----------
         indices : `numpy.ndarray`
             Locations to evaluate the spline.
         collapsed : `numpy.ndarray`
             Collapsed overscan values corresponding to the spline
             evaluation points.
         numBins : `int`
             Number of bins to use in constructing the spline.
  
         Returns
         -------
         interp : `lsst.afw.math.Interpolate`
             Interpolation object for later evaluation.
         """
         if not np.ma.is_masked(collapsed):
             collapsed.mask = np.array(len(collapsed)*[np.ma.nomask])
  
         numPerBin, binEdges = np.histogram(indices, bins=numBins,
                                            weights=1 - collapsed.mask.astype(int))
         with np.errstate(invalid="ignore"):
             values = np.histogram(indices, bins=numBins,
                                   weights=collapsed.data*~collapsed.mask)[0]/numPerBin
             binCenters = np.histogram(indices, bins=numBins,
                                       weights=indices*~collapsed.mask)[0]/numPerBin
             interp = afwMath.makeInterpolate(binCenters.astype(float)[numPerBin > 0],
                                              values.astype(float)[numPerBin > 0],
                                              afwMath.stringToInterpStyle(self.config.fitType))
         return interp
  

◆ transpose()

def lsst.ip.isr.overscan.OverscanCorrectionTask.transpose ( imageArray )

static

Transpose input numpy array if necessary.

Parameters
----------
imageArray : `numpy.ndarray`
    Image data to transpose.

Returns
-------
imageArray : `numpy.ndarray`
    Transposed image data.
isTransposed : `bool`
    Indicates whether the input data was transposed.

Definition at line 268 of file overscan.py.

     def transpose(imageArray):
         """Transpose input numpy array if necessary.
  
         Parameters
         ----------
         imageArray : `numpy.ndarray`
             Image data to transpose.
  
         Returns
         -------
         imageArray : `numpy.ndarray`
             Transposed image data.
         isTransposed : `bool`
             Indicates whether the input data was transposed.
         """
         if np.argmin(imageArray.shape) == 0:
             return np.transpose(imageArray), True
         else:
             return imageArray, False
  

Member Data Documentation

◆ allowDebug

lsst.ip.isr.overscan.OverscanCorrectionTask.allowDebug

Definition at line 92 of file overscan.py.

◆ ConfigClass

lsst.ip.isr.overscan.OverscanCorrectionTask.ConfigClass = OverscanCorrectionTaskConfig

static

Definition at line 87 of file overscan.py.

◆ statControl

lsst.ip.isr.overscan.OverscanCorrectionTask.statControl

Definition at line 95 of file overscan.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/ip_isr/22.0.1-27-g97737f7+2a20fdde0d/python/lsst/ip/isr/overscan.py

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ collapseArray()

◆ collapseArrayMedian()

◆ debugView()

◆ getImageArray()

◆ integerConvert()

◆ maskExtrapolated()

◆ maskOutliers()

◆ measureConstantOverscan()

◆ measureVectorOverscan()

◆ run()

◆ splineEval()

◆ splineFit()

◆ transpose()

Member Data Documentation

◆ allowDebug

◆ ConfigClass

◆ statControl

◆ init()