lsst.afw.image._exposure._multiband.MultibandExposure Class Reference

Inheritance diagram for lsst.afw.image._exposure._multiband.MultibandExposure:

Public Member Functions
	__init__ (self, filters, image, mask, variance, psfs=None)
	computePsfKernelImage (self, position)
	computePsfImage (self, position=None)
	getPsfs (self)

Static Public Member Functions
	fromExposures (filters, singles)
	fromArrays (filters, image, mask, variance, bbox=None)
	fromKwargs (filters, filterKwargs, singleType=ExposureF, **kwargs)
	fromButler (butler, bands, *args, **kwargs)

Public Attributes
	singles

Protected Member Functions
	_buildSingles (self, image=None, mask=None, variance=None)
	_slice (self, filters, filterIndex, indices)

Detailed Description

MultibandExposure class

This class acts as a container for multiple `afw.Exposure` objects.
All exposures must have the same bounding box, and the associated
images must all have the same data type.

See `MultibandTripleBase` for parameter definitions.

Definition at line 119 of file _multiband.py.

Constructor & Destructor Documentation

__init__()

lsst.afw.image._exposure._multiband.MultibandExposure.__init__	(		self,
			filters,
			image,
			mask,
			variance,
			psfs = None )

Reimplemented from lsst.afw.image._image._multiband.MultibandTripleBase.

Definition at line 128 of file _multiband.py.

    def __init__(self, filters, image, mask, variance, psfs=None):
        super().__init__(filters, image, mask, variance)
        if psfs is not None:
            for psf, exposure in zip(psfs, self.singles):
                exposure.setPsf(psf)
 

Member Function Documentation

_buildSingles()

lsst.afw.image._exposure._multiband.MultibandExposure._buildSingles ( self, image = None, mask = None, variance = None )

protected

Make a new list of single band objects

Parameters
----------
image: `list`
    List of `Image` objects that represent the image in each band.
mask: `list`
    List of `Mask` objects that represent the mask in each band.
variance: `list`
    List of `Image` objects that represent the variance in each band.

Returns
-------
singles: tuple
    Tuple of `MaskedImage` objects for each band,
    where the `image`, `mask`, and `variance` of each `single`
    point to the multiband objects.

Definition at line 159 of file _multiband.py.

    def _buildSingles(self, image=None, mask=None, variance=None):
        """Make a new list of single band objects
 
        Parameters
        ----------
        image: `list`
            List of `Image` objects that represent the image in each band.
        mask: `list`
            List of `Mask` objects that represent the mask in each band.
        variance: `list`
            List of `Image` objects that represent the variance in each band.
 
        Returns
        -------
        singles: tuple
            Tuple of `MaskedImage` objects for each band,
            where the `image`, `mask`, and `variance` of each `single`
            point to the multiband objects.
        """
        singles = []
        if image is None:
            image = self.image
        if mask is None:
            mask = self.mask
        if variance is None:
            variance = self.variance
 
        dtype = image.array.dtype
        for f in self.filters:
            maskedImage = MaskedImage(image=image[f], mask=mask[f], variance=variance[f], dtype=dtype)
            single = Exposure(maskedImage, dtype=dtype)
            singles.append(single)
        return tuple(singles)
 

_slice()

lsst.afw.image._exposure._multiband.MultibandExposure._slice ( self, filters, filterIndex, indices )

protected

Slice the current object and return the result

See `Multiband._slice` for a list of the parameters.
This overwrites the base method to attach the PSF to
each individual exposure.

Reimplemented from lsst.afw.image._image._multiband.MultibandTripleBase.

Definition at line 289 of file _multiband.py.

    def _slice(self, filters, filterIndex, indices):
        """Slice the current object and return the result
 
        See `Multiband._slice` for a list of the parameters.
        This overwrites the base method to attach the PSF to
        each individual exposure.
        """
        image = self.image._slice(filters, filterIndex, indices)
        if self.mask is not None:
            mask = self._mask._slice(filters, filterIndex, indices)
        else:
            mask = None
        if self.variance is not None:
            variance = self._variance._slice(filters, filterIndex, indices)
        else:
            variance = None
 
        # If only a single pixel is selected, return the tuple of MultibandPixels
        if isinstance(image, MultibandPixel):
            if mask is not None:
                assert isinstance(mask, MultibandPixel)
            if variance is not None:
                assert isinstance(variance, MultibandPixel)
            return (image, mask, variance)
 
        _psfs = self.getPsfs()
        psfs = [_psfs[band] for band in filters]
 
        result = MultibandExposure(
            filters=filters,
            image=image,
            mask=mask,
            variance=variance,
            psfs=psfs,
        )
 
        assert all([r.getBBox() == result._bbox for r in [result._mask, result._variance]])
        return result

computePsfImage()

lsst.afw.image._exposure._multiband.MultibandExposure.computePsfImage	(		self,
			position = None )

Get a multiband PSF image

The PSF Kernel Image is computed for each band
and combined into a (filter, y, x) array and stored
as `self._psfImage`.
The result is not cached, so if the same PSF is expected
to be used multiple times it is a good idea to store the
result in another variable.

Parameters
----------
position: `Point2D` or `tuple`
    Coordinates to evaluate the PSF. If `position` is `None`
    then `Psf.getAveragePosition()` is used.

Returns
-------
self._psfImage: array
    The multiband PSF image.

Definition at line 252 of file _multiband.py.

    def computePsfImage(self, position=None):
        """Get a multiband PSF image
 
        The PSF Kernel Image is computed for each band
        and combined into a (filter, y, x) array and stored
        as `self._psfImage`.
        The result is not cached, so if the same PSF is expected
        to be used multiple times it is a good idea to store the
        result in another variable.
 
        Parameters
        ----------
        position: `Point2D` or `tuple`
            Coordinates to evaluate the PSF. If `position` is `None`
            then `Psf.getAveragePosition()` is used.
 
        Returns
        -------
        self._psfImage: array
            The multiband PSF image.
        """
        return computePsfImage(
            psfModels=self.getPsfs(),
            position=position,
            useKernelImage=True,
        )
 

computePsfKernelImage()

lsst.afw.image._exposure._multiband.MultibandExposure.computePsfKernelImage	(		self,
			position )

Get a multiband PSF image

The PSF Kernel Image is computed for each band
and combined into a (filter, y, x) array and stored
as `self._psfImage`.
The result is not cached, so if the same PSF is expected
to be used multiple times it is a good idea to store the
result in another variable.

Parameters
----------
position: `Point2D` or `tuple`
    Coordinates to evaluate the PSF.

Returns
-------
self._psfImage: array
    The multiband PSF image.

Definition at line 226 of file _multiband.py.

    def computePsfKernelImage(self, position):
        """Get a multiband PSF image
 
        The PSF Kernel Image is computed for each band
        and combined into a (filter, y, x) array and stored
        as `self._psfImage`.
        The result is not cached, so if the same PSF is expected
        to be used multiple times it is a good idea to store the
        result in another variable.
 
        Parameters
        ----------
        position: `Point2D` or `tuple`
            Coordinates to evaluate the PSF.
 
        Returns
        -------
        self._psfImage: array
            The multiband PSF image.
        """
        return computePsfImage(
            psfModels=self.getPsfs(),
            position=position,
            useKernelImage=True,
        )
 

fromArrays()

lsst.afw.image._exposure._multiband.MultibandExposure.fromArrays ( filters, image, mask, variance, bbox = None )

static

Construct a MultibandExposure from a collection of arrays

see `tripleFromArrays` for a description of parameters

Definition at line 144 of file _multiband.py.

    def fromArrays(filters, image, mask, variance, bbox=None):
        """Construct a MultibandExposure from a collection of arrays
 
        see `tripleFromArrays` for a description of parameters
        """
        return tripleFromArrays(MultibandExposure, filters, image, mask, variance, bbox)
 

fromButler()

lsst.afw.image._exposure._multiband.MultibandExposure.fromButler ( butler, bands, * args, ** kwargs )

static

Load a multiband exposure from a butler

Because each band is stored in a separate exposure file,
this method can be used to load all of the exposures for
a given set of bands

Parameters
----------
butler: `lsst.daf.butler.Butler`
    Butler connection to use to load the single band
    calibrated images
bands: `list` or `str`
    List of names for each band
args: `list`
    Arguments to the Butler.
kwargs: `dict`
    Keyword arguments to pass to the Butler
    that are the same in all bands.

Returns
-------
result: `MultibandExposure`
    The new `MultibandExposure` created by combining all of the
    single band exposures.

Definition at line 194 of file _multiband.py.

    def fromButler(butler, bands, *args, **kwargs):
        """Load a multiband exposure from a butler
 
        Because each band is stored in a separate exposure file,
        this method can be used to load all of the exposures for
        a given set of bands
 
        Parameters
        ----------
        butler: `lsst.daf.butler.Butler`
            Butler connection to use to load the single band
            calibrated images
        bands: `list` or `str`
            List of names for each band
        args: `list`
            Arguments to the Butler.
        kwargs: `dict`
            Keyword arguments to pass to the Butler
            that are the same in all bands.
 
        Returns
        -------
        result: `MultibandExposure`
            The new `MultibandExposure` created by combining all of the
            single band exposures.
        """
        # Load the Exposure in each band
        exposures = []
        for band in bands:
            exposures.append(butler.get(*args, band=band, **kwargs))
        return MultibandExposure.fromExposures(bands, exposures)
 

fromExposures()

lsst.afw.image._exposure._multiband.MultibandExposure.fromExposures ( filters, singles )

static

Construct a MultibandImage from a collection of single band images

see `tripleFromExposures` for a description of parameters

Definition at line 135 of file _multiband.py.

    def fromExposures(filters, singles):
        """Construct a MultibandImage from a collection of single band images
 
        see `tripleFromExposures` for a description of parameters
        """
        psfs = [s.getPsf() for s in singles]
        return tripleFromSingles(MultibandExposure, filters, singles, psfs=psfs)
 

fromKwargs()

lsst.afw.image._exposure._multiband.MultibandExposure.fromKwargs ( filters, filterKwargs, singleType = ExposureF, ** kwargs )

static

Build a MultibandImage from a set of keyword arguments

see `makeTripleFromKwargs` for a description of parameters

Definition at line 152 of file _multiband.py.

    def fromKwargs(filters, filterKwargs, singleType=ExposureF, **kwargs):
        """Build a MultibandImage from a set of keyword arguments
 
        see `makeTripleFromKwargs` for a description of parameters
        """
        return makeTripleFromKwargs(MultibandExposure, filters, filterKwargs, singleType, **kwargs)
 

getPsfs()

lsst.afw.image._exposure._multiband.MultibandExposure.getPsfs

(

self

)

Extract the PSF model in each band

Returns
-------
psfs : `dict` of `lsst.afw.detection.Psf`
    The PSF in each band

Definition at line 279 of file _multiband.py.

    def getPsfs(self):
        """Extract the PSF model in each band
 
        Returns
        -------
        psfs : `dict` of `lsst.afw.detection.Psf`
            The PSF in each band
        """
        return {band: self[band].getPsf() for band in self.filters}
 

Member Data Documentation

singles

lsst.afw.image._exposure._multiband.MultibandExposure.singles

Definition at line 131 of file _multiband.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+66d966b544/python/lsst/afw/image/_exposure/_multiband.py