lsst.pipe.tasks.background Namespace Reference

Classes
class	BackgroundConfig
class	FocalPlaneBackground
class	FocalPlaneBackgroundConfig
class	MaskObjectsConfig
class	MaskObjectsTask
class	SkyMeasurementConfig
class	SkyMeasurementTask
class	SkyStatsConfig

Functions
	robustMean (array, rej=3.0)
	interpolate1D (method, xSample, ySample, xInterp)
	interpolateBadPixels (array, isBad, interpolationStyle)
	smoothArray (array, bad, sigma)
	_create_module_child (name)

Variables
	pipe_drivers = _create_module_child("lsst.pipe.drivers")
	pipe_drivers_background = _create_module_child("lsst.pipe.drivers.background")

Function Documentation

_create_module_child()

lsst.pipe.tasks.background._create_module_child ( name )

protected

Create an empty module attached to the relevant parent.

Definition at line 909 of file background.py.

def _create_module_child(name):
    """Create an empty module attached to the relevant parent."""
    parent, child = name.rsplit(".", 1)
    spec = importlib.machinery.ModuleSpec(name, None)
    newmod = importlib.util.module_from_spec(spec)
    setattr(sys.modules[parent], child, newmod)
    sys.modules[name] = newmod
    return newmod
 
 
# This module used to be located in pipe_drivers as
# lsst.pipe.drivers.background.  All pickled datasets using this name
# require that it still exists as that name. Therefore we create a faked
# version of lsst.pipe.drivers if that package is not around.

interpolate1D()

lsst.pipe.tasks.background.interpolate1D	(		method,
			xSample,
			ySample,
			xInterp )

Interpolate in one dimension

Interpolates the curve provided by `xSample` and `ySample` at
the positions of `xInterp`. Automatically backs off the
interpolation method to achieve successful interpolation.

Parameters
----------
method : `lsst.afw.math.Interpolate.Style`
    Interpolation method to use.
xSample : `numpy.ndarray`
    Vector of ordinates.
ySample : `numpy.ndarray`
    Vector of coordinates.
xInterp : `numpy.ndarray`
    Vector of ordinates to which to interpolate.

Returns
-------
yInterp : `numpy.ndarray`
    Vector of interpolated coordinates.

Definition at line 393 of file background.py.

def interpolate1D(method, xSample, ySample, xInterp):
    """Interpolate in one dimension
 
    Interpolates the curve provided by `xSample` and `ySample` at
    the positions of `xInterp`. Automatically backs off the
    interpolation method to achieve successful interpolation.
 
    Parameters
    ----------
    method : `lsst.afw.math.Interpolate.Style`
        Interpolation method to use.
    xSample : `numpy.ndarray`
        Vector of ordinates.
    ySample : `numpy.ndarray`
        Vector of coordinates.
    xInterp : `numpy.ndarray`
        Vector of ordinates to which to interpolate.
 
    Returns
    -------
    yInterp : `numpy.ndarray`
        Vector of interpolated coordinates.
 
    """
    if len(xSample) == 0:
        return numpy.ones_like(xInterp)*numpy.nan
    try:
        return afwMath.makeInterpolate(xSample.astype(float), ySample.astype(float),
                                       method).interpolate(xInterp.astype(float))
    except Exception:
        if method == afwMath.Interpolate.CONSTANT:
            # We've already tried the most basic interpolation and it failed
            return numpy.ones_like(xInterp)*numpy.nan
        newMethod = afwMath.lookupMaxInterpStyle(len(xSample))
        if newMethod == method:
            newMethod = afwMath.Interpolate.CONSTANT
        return interpolate1D(newMethod, xSample, ySample, xInterp)
 
 

interpolateBadPixels()

lsst.pipe.tasks.background.interpolateBadPixels	(		array,
			isBad,
			interpolationStyle )

Interpolate bad pixels in an image array

The bad pixels are modified in the array.

Parameters
----------
array : `numpy.ndarray`
    Image array with bad pixels.
isBad : `numpy.ndarray` of type `bool`
    Boolean array indicating which pixels are bad.
interpolationStyle : `str`
    Style for interpolation (see `lsst.afw.math.Background`);
    supported values are CONSTANT, LINEAR, NATURAL_SPLINE,
    AKIMA_SPLINE.

Definition at line 432 of file background.py.

def interpolateBadPixels(array, isBad, interpolationStyle):
    """Interpolate bad pixels in an image array
 
    The bad pixels are modified in the array.
 
    Parameters
    ----------
    array : `numpy.ndarray`
        Image array with bad pixels.
    isBad : `numpy.ndarray` of type `bool`
        Boolean array indicating which pixels are bad.
    interpolationStyle : `str`
        Style for interpolation (see `lsst.afw.math.Background`);
        supported values are CONSTANT, LINEAR, NATURAL_SPLINE,
        AKIMA_SPLINE.
    """
    if numpy.all(isBad):
        raise RuntimeError("No good pixels in image array")
    height, width = array.shape
    xIndices = numpy.arange(width, dtype=float)
    yIndices = numpy.arange(height, dtype=float)
    method = afwMath.stringToInterpStyle(interpolationStyle)
    isGood = ~isBad
    for y in range(height):
        if numpy.any(isBad[y, :]) and numpy.any(isGood[y, :]):
            array[y][isBad[y]] = interpolate1D(method, xIndices[isGood[y]], array[y][isGood[y]],
                                               xIndices[isBad[y]])
 
    isBad = numpy.isnan(array)
    isGood = ~isBad
    for x in range(width):
        if numpy.any(isBad[:, x]) and numpy.any(isGood[:, x]):
            array[:, x][isBad[:, x]] = interpolate1D(method, yIndices[isGood[:, x]],
                                                     array[:, x][isGood[:, x]], yIndices[isBad[:, x]])
 
 

robustMean()

lsst.pipe.tasks.background.robustMean	(		array,
			rej = 3.0 )

Measure a robust mean of an array

Parameters
----------
array : `numpy.ndarray`
    Array for which to measure the mean.
rej : `float`
    k-sigma rejection threshold.

Returns
-------
mean : `array.dtype`
    Robust mean of `array`.

Definition at line 51 of file background.py.

def robustMean(array, rej=3.0):
    """Measure a robust mean of an array
 
    Parameters
    ----------
    array : `numpy.ndarray`
        Array for which to measure the mean.
    rej : `float`
        k-sigma rejection threshold.
 
    Returns
    -------
    mean : `array.dtype`
        Robust mean of `array`.
    """
    q1, median, q3 = numpy.percentile(array, [25.0, 50.0, 100.0])
    good = numpy.abs(array - median) < rej*0.74*(q3 - q1)
    return array[good].mean()
 
 

smoothArray()

lsst.pipe.tasks.background.smoothArray	(		array,
			bad,
			sigma )

Gaussian-smooth an array while ignoring bad pixels

It's not sufficient to set the bad pixels to zero, as then they're treated
as if they are zero, rather than being ignored altogether. We need to apply
a correction to that image that removes the effect of the bad pixels.

Parameters
----------
array : `numpy.ndarray` of floating-point
    Array to smooth.
bad : `numpy.ndarray` of `bool`
    Flag array indicating bad pixels.
sigma : `float`
    Gaussian sigma.

Returns
-------
convolved : `numpy.ndarray`
    Smoothed image.

Definition at line 883 of file background.py.

def smoothArray(array, bad, sigma):
    """Gaussian-smooth an array while ignoring bad pixels
 
    It's not sufficient to set the bad pixels to zero, as then they're treated
    as if they are zero, rather than being ignored altogether. We need to apply
    a correction to that image that removes the effect of the bad pixels.
 
    Parameters
    ----------
    array : `numpy.ndarray` of floating-point
        Array to smooth.
    bad : `numpy.ndarray` of `bool`
        Flag array indicating bad pixels.
    sigma : `float`
        Gaussian sigma.
 
    Returns
    -------
    convolved : `numpy.ndarray`
        Smoothed image.
    """
    convolved = gaussian_filter(numpy.where(bad, 0.0, array), sigma, mode="constant", cval=0.0)
    denominator = gaussian_filter(numpy.where(bad, 0.0, 1.0), sigma, mode="constant", cval=0.0)
    return convolved/denominator
 
 

Variable Documentation

pipe_drivers

lsst.pipe.tasks.background.pipe_drivers = _create_module_child("lsst.pipe.drivers")

Definition at line 927 of file background.py.

pipe_drivers_background

lsst.pipe.tasks.background.pipe_drivers_background = _create_module_child("lsst.pipe.drivers.background")

Definition at line 930 of file background.py.