LSSTApplications  18.0.0+56,19.0.0+1,19.0.0+18,19.0.0+19,19.0.0+21,19.0.0+26,19.0.0+5,19.0.0-1-g20d9b18+12,19.0.0-1-g425ff20,19.0.0-1-g5549ca4,19.0.0-1-g580fafe+12,19.0.0-1-g6fe20d0+4,19.0.0-1-g8c57eb9+12,19.0.0-1-ga72da6b,19.0.0-1-gbfe0924+3,19.0.0-1-gdc0e4a7+17,19.0.0-1-ge272bc4+12,19.0.0-1-ge3aa853+3,19.0.0-16-g3a790c8c,19.0.0-18-g955d782+1,19.0.0-2-g0d9f9cd+19,19.0.0-2-g260436e+3,19.0.0-2-g9b11441+6,19.0.0-2-gd955cfd+25,19.0.0-3-g6513920+3,19.0.0-3-gc4f6e04+2,19.0.0-4-g41ffa1d+5,19.0.0-4-g725f80e+21,19.0.0-5-g0745e3f+3,19.0.0-6-g5a632bb5+1,19.0.0-6-gb6b8b0a+3,19.0.0-7-g686a884,19.0.0-7-gea0a0fe+8,19.0.0-9-gd2f60f3c3,w.2020.03
LSSTDataManagementBasePackage
Classes | Functions
lsst.pipe.drivers.background Namespace Reference

Classes

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

Functions

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

Function Documentation

◆ interpolate1D()

def lsst.pipe.drivers.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 376 of file background.py.

376 def interpolate1D(method, xSample, ySample, xInterp):
377  """Interpolate in one dimension
378 
379  Interpolates the curve provided by `xSample` and `ySample` at
380  the positions of `xInterp`. Automatically backs off the
381  interpolation method to achieve successful interpolation.
382 
383  Parameters
384  ----------
385  method : `lsst.afw.math.Interpolate.Style`
386  Interpolation method to use.
387  xSample : `numpy.ndarray`
388  Vector of ordinates.
389  ySample : `numpy.ndarray`
390  Vector of coordinates.
391  xInterp : `numpy.ndarray`
392  Vector of ordinates to which to interpolate.
393 
394  Returns
395  -------
396  yInterp : `numpy.ndarray`
397  Vector of interpolated coordinates.
398 
399  """
400  if len(xSample) == 0:
401  return numpy.ones_like(xInterp)*numpy.nan
402  try:
403  return afwMath.makeInterpolate(xSample.astype(float), ySample.astype(float),
404  method).interpolate(xInterp.astype(float))
405  except Exception:
406  if method == afwMath.Interpolate.CONSTANT:
407  # We've already tried the most basic interpolation and it failed
408  return numpy.ones_like(xInterp)*numpy.nan
409  newMethod = afwMath.lookupMaxInterpStyle(len(xSample))
410  if newMethod == method:
411  newMethod = afwMath.Interpolate.CONSTANT
412  return interpolate1D(newMethod, xSample, ySample, xInterp)
413 
414 
def interpolate1D(method, xSample, ySample, xInterp)
Definition: background.py:376
std::shared_ptr< Interpolate > makeInterpolate(ndarray::Array< double const, 1 > const &x, ndarray::Array< double const, 1 > const &y, Interpolate::Style const style=Interpolate::AKIMA_SPLINE)
Definition: Interpolate.cc:353
Interpolate::Style lookupMaxInterpStyle(int const n)
Get the highest order Interpolation::Style available for &#39;n&#39; points.
Definition: Interpolate.cc:275

◆ interpolateBadPixels()

def lsst.pipe.drivers.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 415 of file background.py.

415 def interpolateBadPixels(array, isBad, interpolationStyle):
416  """Interpolate bad pixels in an image array
417 
418  The bad pixels are modified in the array.
419 
420  Parameters
421  ----------
422  array : `numpy.ndarray`
423  Image array with bad pixels.
424  isBad : `numpy.ndarray` of type `bool`
425  Boolean array indicating which pixels are bad.
426  interpolationStyle : `str`
427  Style for interpolation (see `lsst.afw.math.Background`);
428  supported values are CONSTANT, LINEAR, NATURAL_SPLINE,
429  AKIMA_SPLINE.
430  """
431  if numpy.all(isBad):
432  raise RuntimeError("No good pixels in image array")
433  height, width = array.shape
434  xIndices = numpy.arange(width, dtype=float)
435  yIndices = numpy.arange(height, dtype=float)
436  method = afwMath.stringToInterpStyle(interpolationStyle)
437  isGood = ~isBad
438  for y in range(height):
439  if numpy.any(isBad[y, :]) and numpy.any(isGood[y, :]):
440  array[y][isBad[y]] = interpolate1D(method, xIndices[isGood[y]], array[y][isGood[y]],
441  xIndices[isBad[y]])
442 
443  isBad = numpy.isnan(array)
444  isGood = ~isBad
445  for x in range(width):
446  if numpy.any(isBad[:, x]) and numpy.any(isGood[:, x]):
447  array[:, x][isBad[:, x]] = interpolate1D(method, yIndices[isGood[:, x]],
448  array[:, x][isGood[:, x]], yIndices[isBad[:, x]])
449 
450 
Interpolate::Style stringToInterpStyle(std::string const &style)
Conversion function to switch a string to an Interpolate::Style.
Definition: Interpolate.cc:257
def interpolateBadPixels(array, isBad, interpolationStyle)
Definition: background.py:415
def interpolate1D(method, xSample, ySample, xInterp)
Definition: background.py:376

◆ robustMean()

def lsst.pipe.drivers.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 17 of file background.py.

17 def robustMean(array, rej=3.0):
18  """Measure a robust mean of an array
19 
20  Parameters
21  ----------
22  array : `numpy.ndarray`
23  Array for which to measure the mean.
24  rej : `float`
25  k-sigma rejection threshold.
26 
27  Returns
28  -------
29  mean : `array.dtype`
30  Robust mean of `array`.
31  """
32  q1, median, q3 = numpy.percentile(array, [25.0, 50.0, 100.0])
33  good = numpy.abs(array - median) < rej*0.74*(q3 - q1)
34  return array[good].mean()
35 
36 
def robustMean(array, rej=3.0)
Definition: background.py:17

◆ smoothArray()

def lsst.pipe.drivers.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 849 of file background.py.

849 def smoothArray(array, bad, sigma):
850  """Gaussian-smooth an array while ignoring bad pixels
851 
852  It's not sufficient to set the bad pixels to zero, as then they're treated
853  as if they are zero, rather than being ignored altogether. We need to apply
854  a correction to that image that removes the effect of the bad pixels.
855 
856  Parameters
857  ----------
858  array : `numpy.ndarray` of floating-point
859  Array to smooth.
860  bad : `numpy.ndarray` of `bool`
861  Flag array indicating bad pixels.
862  sigma : `float`
863  Gaussian sigma.
864 
865  Returns
866  -------
867  convolved : `numpy.ndarray`
868  Smoothed image.
869  """
870  convolved = gaussian_filter(numpy.where(bad, 0.0, array), sigma, mode="constant", cval=0.0)
871  denominator = gaussian_filter(numpy.where(bad, 0.0, 1.0), sigma, mode="constant", cval=0.0)
872  return convolved/denominator
873 
def smoothArray(array, bad, sigma)
Definition: background.py:849