lsst.afw.math.backgroundList.BackgroundList Class Reference

Public Member Functions
def	__init__ (self, *args)
def	__getitem__ (self, *args)
def	__len__ (self, *args)
def	append (self, val)
def	clone (self)
def	writeFits (self, fileName, flags=0)
def	getImage (self)
def	__reduce__ (self)

Static Public Member Functions
def	readFits (fileName, hdu=0, flags=0)

Detailed Description

A list-like class to contain a list of (`lsst.afw.math.Background`,
`lsst.afw.math.Interpolate.Style`, `~lsst.afw.math.UndersampleStyle`)
tuples.

Parameters
----------
*args : `tuple` or `~lsst.afw.math.Background`
    A sequence of arguments, each of which becomes an element of the list.
    We also accept a single `lsst.afw.math.Background` and extract the
    ``interpStyle`` and ``undersampleStyle`` from the as-used values.

Definition at line 35 of file backgroundList.py.

Constructor & Destructor Documentation

__init__()

def lsst.afw.math.backgroundList.BackgroundList.__init__	(		self,
		*	args
	)

Definition at line 48 of file backgroundList.py.

    def __init__(self, *args):
        self._backgrounds = []
        for a in args:
            self.append(a)
 

Member Function Documentation

__getitem__()

def lsst.afw.math.backgroundList.BackgroundList.__getitem__	(		self,
		*	args
	)

Return an item

Parameters
----------
*args
    Any valid list index.

Definition at line 53 of file backgroundList.py.

    def __getitem__(self, *args):
        """Return an item
 
        Parameters
        ----------
        *args
            Any valid list index.
        """
        #
        # Set any previously-unknown Styles (they are set by bkgd.getImage())
        #
        for i, val in enumerate(self._backgrounds):
            bkgd, interpStyle, undersampleStyle, approxStyle, \
                approxOrderX, approxOrderY, approxWeighting = val
            if interpStyle is None or undersampleStyle is None:
                interpStyle = bkgd.getAsUsedInterpStyle()
                undersampleStyle = bkgd.getAsUsedUndersampleStyle()
                actrl = bkgd.getBackgroundControl().getApproximateControl()
                approxStyle = actrl.getStyle()
                approxOrderX = actrl.getOrderX()
                approxOrderY = actrl.getOrderY()
                approxWeighting = actrl.getWeighting()
                self._backgrounds[i] = (bkgd, interpStyle, undersampleStyle,
                                        approxStyle, approxOrderX, approxOrderY, approxWeighting)
        #
        # And return what they wanted
        #
        return self._backgrounds.__getitem__(*args)
 

__len__()

def lsst.afw.math.backgroundList.BackgroundList.__len__	(		self,
		*	args
	)

Definition at line 82 of file backgroundList.py.

    def __len__(self, *args):
        return self._backgrounds.__len__(*args)
 

__reduce__()

def lsst.afw.math.backgroundList.BackgroundList.__reduce__

(

self

)

Definition at line 237 of file backgroundList.py.

    def __reduce__(self):
        return reduceToFits(self)

append()

def lsst.afw.math.backgroundList.BackgroundList.append	(		self,
			val
	)

Definition at line 85 of file backgroundList.py.

    def append(self, val):
        try:
            bkgd, interpStyle, undersampleStyle, approxStyle, \
                approxOrderX, approxOrderY, approxWeighting = val
        except TypeError:
            bkgd = val
            interpStyle = None
            undersampleStyle = None
            approxStyle = None
            approxOrderX = None
            approxOrderY = None
            approxWeighting = None
 
        bgInfo = (bkgd, interpStyle, undersampleStyle, approxStyle,
                  approxOrderX, approxOrderY, approxWeighting)
        self._backgrounds.append(bgInfo)
 

clone()

def lsst.afw.math.backgroundList.BackgroundList.clone

(

self

)

Return a shallow copy

Shallow copies do not share backgrounds that are appended after copying,
but do share changes to contained background objects.

Definition at line 102 of file backgroundList.py.

    def clone(self):
        """Return a shallow copy
 
        Shallow copies do not share backgrounds that are appended after copying,
        but do share changes to contained background objects.
        """
        return BackgroundList(*self)
 

getImage()

def lsst.afw.math.backgroundList.BackgroundList.getImage

(

self

)

Compute and return a full-resolution image from our list of
(Background, interpStyle, undersampleStyle).

Definition at line 216 of file backgroundList.py.

    def getImage(self):
        """Compute and return a full-resolution image from our list of
        (Background, interpStyle, undersampleStyle).
        """
 
        bkgdImage = None
        for (bkgd, interpStyle, undersampleStyle, approxStyle,
             approxOrderX, approxOrderY, approxWeighting) in self:
            if not bkgdImage:
                if approxStyle != ApproximateControl.UNKNOWN:
                    bkgdImage = bkgd.getImageF()
                else:
                    bkgdImage = bkgd.getImageF(interpStyle, undersampleStyle)
            else:
                if approxStyle != ApproximateControl.UNKNOWN:
                    bkgdImage += bkgd.getImageF()
                else:
                    bkgdImage += bkgd.getImageF(interpStyle, undersampleStyle)
 
        return bkgdImage
 

readFits()

def lsst.afw.math.backgroundList.BackgroundList.readFits (   fileName,   hdu = 0,   flags = 0  )

static

Read our list of Backgrounds from a file.

Parameters
----------
fileName : `str`
    FITS file to read
hdu : `int`
    First Header/Data Unit to attempt to read from
flags : `int`
    Flags to control details of reading; currently unused, but present
    for consistency with `lsst.afw.table.BaseCatalog.readFits`.

See Also
--------
getImage

Definition at line 146 of file backgroundList.py.

    def readFits(fileName, hdu=0, flags=0):
        """Read our list of Backgrounds from a file.
 
        Parameters
        ----------
        fileName : `str`
            FITS file to read
        hdu : `int`
            First Header/Data Unit to attempt to read from
        flags : `int`
            Flags to control details of reading; currently unused, but present
            for consistency with `lsst.afw.table.BaseCatalog.readFits`.
 
        See Also
        --------
        getImage
        """
        if not isinstance(fileName, MemFileManager) and not os.path.exists(fileName):
            raise RuntimeError(f"File not found: {fileName}")
 
        self = BackgroundList()
 
        f = Fits(fileName, 'r')
        nHdus = f.countHdus()
        f.closeFile()
        if nHdus % 3 != 0:
            raise RuntimeError(f"BackgroundList FITS file {fileName} has {nHdus} HDUs;"
                               f"expected a multiple of 3 (compression is not supported).")
 
        for hdu in range(0, nHdus, 3):
            # It seems like we ought to be able to just use
            # MaskedImageFitsReader here, but it warns about EXTTYPE and still
            # doesn't work quite naturally when starting from a nonzero HDU.
            imageReader = afwImage.ImageFitsReader(fileName, hdu=hdu)
            maskReader = afwImage.MaskFitsReader(fileName, hdu=hdu + 1)
            varianceReader = afwImage.ImageFitsReader(fileName, hdu=hdu + 2)
            statsImage = afwImage.MaskedImageF(imageReader.read(), maskReader.read(), varianceReader.read())
            md = imageReader.readMetadata()
 
            x0 = md["BKGD_X0"]
            y0 = md["BKGD_Y0"]
            width = md["BKGD_WIDTH"]
            height = md["BKGD_HEIGHT"]
            imageBBox = lsst.geom.BoxI(lsst.geom.PointI(x0, y0), lsst.geom.ExtentI(width, height))
 
            interpStyle = Interpolate.Style(md["INTERPSTYLE"])
            undersampleStyle = UndersampleStyle(md["UNDERSAMPLESTYLE"])
 
            # Older outputs won't have APPROX* settings.  Provide alternative defaults.
            # Note: Currently X- and Y-orders must be equal due to a limitation in
            #       math::Chebyshev1Function2.  Setting approxOrderY = -1 is equivalent
            #       to saying approxOrderY = approxOrderX.
            approxStyle = md.get("APPROXSTYLE", ApproximateControl.UNKNOWN)
            approxStyle = ApproximateControl.Style(approxStyle)
            approxOrderX = md.get("APPROXORDERX", 1)
            approxOrderY = md.get("APPROXORDERY", -1)
            approxWeighting = md.get("APPROXWEIGHTING", True)
 
            bkgd = BackgroundMI(imageBBox, statsImage)
            bctrl = bkgd.getBackgroundControl()
            bctrl.setInterpStyle(interpStyle)
            bctrl.setUndersampleStyle(undersampleStyle)
            actrl = ApproximateControl(approxStyle, approxOrderX, approxOrderY, approxWeighting)
            bctrl.setApproximateControl(actrl)
            bgInfo = (bkgd, interpStyle, undersampleStyle, approxStyle,
                      approxOrderX, approxOrderY, approxWeighting)
            self.append(bgInfo)
 
        return self
 

writeFits()

def lsst.afw.math.backgroundList.BackgroundList.writeFits	(		self,
			fileName,
			flags = 0
	)

Save our list of Backgrounds to a file.

Parameters
-----------
fileName : `str`
    FITS file to write
flags : `int`
    Flags to control details of writing; currently unused, but present
    for consistency with `lsst.afw.table.BaseCatalog.writeFits`.

Definition at line 110 of file backgroundList.py.

    def writeFits(self, fileName, flags=0):
        """Save our list of Backgrounds to a file.
 
        Parameters
        -----------
        fileName : `str`
            FITS file to write
        flags : `int`
            Flags to control details of writing; currently unused, but present
            for consistency with `lsst.afw.table.BaseCatalog.writeFits`.
        """
 
        for i, bkgd in enumerate(self):
            (bkgd, interpStyle, undersampleStyle, approxStyle, approxOrderX, approxOrderY,
             approxWeighting) = bkgd
 
            statsImage = bkgd.getStatsImage()
 
            md = dafBase.PropertyList()
            md.set("INTERPSTYLE", int(interpStyle))
            md.set("UNDERSAMPLESTYLE", int(undersampleStyle))
            md.set("APPROXSTYLE", int(approxStyle))
            md.set("APPROXORDERX", approxOrderX)
            md.set("APPROXORDERY", approxOrderY)
            md.set("APPROXWEIGHTING", approxWeighting)
            bbox = bkgd.getImageBBox()
            md.set("BKGD_X0", bbox.getMinX())
            md.set("BKGD_Y0", bbox.getMinY())
            md.set("BKGD_WIDTH", bbox.getWidth())
            md.set("BKGD_HEIGHT", bbox.getHeight())
 
            statsImage.getImage().writeFits(fileName, md, "w" if i == 0 else "a")
            statsImage.getMask().writeFits(fileName, md, "a")
            statsImage.getVariance().writeFits(fileName, md, "a")
 

---

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

• /j/snowflake/release/lsstsw/stack/0.3.1/Linux64/afw/21.0.0-15-gedb9d5423+1041c3824f/python/lsst/afw/math/backgroundList.py