lsst.meas.algorithms.stamps.StampsBase Class Reference

Inheritance diagram for lsst.meas.algorithms.stamps.StampsBase:

Public Member Functions
def	__init__ (self, stamps, metadata=None, use_mask=True, use_variance=True, use_archive=False)
def	readFits (cls, filename)
def	readFitsWithOptions (cls, filename, options)
def	writeFits (self, filename)
def	__len__ (self)
def	__getitem__ (self, index)
def	__iter__ (self)
def	getMaskedImages (self)
def	getArchiveElements (self)
def	metadata (self)

Public Attributes
	use_mask
	use_variance
	use_archive

Detailed Description

Collection of  stamps and associated metadata.

Parameters
----------
stamps : iterable
    This should be an iterable of dataclass objects
    a la ``lsst.meas.algorithms.Stamp``.
metadata : `lsst.daf.base.PropertyList`, optional
    Metadata associated with the objects within the stamps.
use_mask : `bool`, optional
    If ``True`` read and write the mask data.  Default ``True``.
use_variance : `bool`, optional
    If ``True`` read and write the variance data. Default ``True``.
use_archive : `bool`, optional
    If ``True``, read and write an Archive that contains a Persistable
    associated with each stamp, for example a Transform or a WCS.
    Default ``False``.

Notes
-----
A butler can be used to read only a part of the stamps,
specified by a bbox:

>>> starSubregions = butler.get("brightStarStamps", dataId, parameters={'bbox': bbox})

Definition at line 271 of file stamps.py.

Constructor & Destructor Documentation

__init__()

def lsst.meas.algorithms.stamps.StampsBase.__init__	(		self,
			stamps,
			metadata = None,
			use_mask = True,
			use_variance = True,
			use_archive = False
	)

Definition at line 298 of file stamps.py.

                 use_archive=False):
        if not hasattr(stamps, '__iter__'):
            raise ValueError('The stamps parameter must be iterable.')
        for stamp in stamps:
            if not isinstance(stamp, AbstractStamp):
                raise ValueError('The entries in stamps must inherit from AbstractStamp.  '
                                 f'Got {type(stamp)}.')
        self._stamps = stamps
        self._metadata = PropertyList() if metadata is None else metadata.deepCopy()
        self.use_mask = use_mask
        self.use_variance = use_variance
        self.use_archive = use_archive
 

Member Function Documentation

__getitem__()

def lsst.meas.algorithms.stamps.StampsBase.__getitem__	(		self,
			index
	)

Definition at line 379 of file stamps.py.

    def __getitem__(self, index):
        return self._stamps[index]
 

__iter__()

def lsst.meas.algorithms.stamps.StampsBase.__iter__

(

self

)

Definition at line 382 of file stamps.py.

    def __iter__(self):
        return iter(self._stamps)
 

__len__()

def lsst.meas.algorithms.stamps.StampsBase.__len__

(

self

)

Definition at line 376 of file stamps.py.

    def __len__(self):
        return len(self._stamps)
 

getArchiveElements()

def lsst.meas.algorithms.stamps.StampsBase.getArchiveElements

(

self

)

Retrieve archive elements associated with each stamp.

Returns
-------
archiveElements :
    `list` [`lsst.afwTable.io.Persistable`]

Definition at line 395 of file stamps.py.

    def getArchiveElements(self):
        """Retrieve archive elements associated with each stamp.
 
        Returns
        -------
        archiveElements :
            `list` [`lsst.afwTable.io.Persistable`]
        """
        return [stamp.archive_element for stamp in self._stamps]
 

getMaskedImages()

def lsst.meas.algorithms.stamps.StampsBase.getMaskedImages

(

self

)

Retrieve star images.

Returns
-------
maskedImages :
    `list` [`lsst.afw.image.maskedImage.maskedImage.MaskedImageF`]

Definition at line 385 of file stamps.py.

    def getMaskedImages(self):
        """Retrieve star images.
 
        Returns
        -------
        maskedImages :
            `list` [`lsst.afw.image.maskedImage.maskedImage.MaskedImageF`]
        """
        return [stamp.stamp_im for stamp in self._stamps]
 

metadata()

def lsst.meas.algorithms.stamps.StampsBase.metadata

(

self

)

Definition at line 406 of file stamps.py.

    def metadata(self):
        return self._metadata
 
 

readFits()

def lsst.meas.algorithms.stamps.StampsBase.readFits	(		cls,
			filename
	)

Build an instance of this class from a file.

Parameters
----------
filename : `str`
    Name of the file to read

Reimplemented in lsst.meas.algorithms.stamps.Stamps, and lsst.meas.algorithms.brightStarStamps.BrightStarStamps.

Definition at line 313 of file stamps.py.

    def readFits(cls, filename):
        """Build an instance of this class from a file.
 
        Parameters
        ----------
        filename : `str`
            Name of the file to read
        """
 
        return cls.readFitsWithOptions(filename, None)
 

readFitsWithOptions()

def lsst.meas.algorithms.stamps.StampsBase.readFitsWithOptions	(		cls,
			filename,
			options
	)

Build an instance of this class with options.

Parameters
----------
filename : `str`
    Name of the file to read
options : `PropertyList`
    Collection of metadata parameters

Reimplemented in lsst.meas.algorithms.stamps.Stamps, and lsst.meas.algorithms.brightStarStamps.BrightStarStamps.

Definition at line 325 of file stamps.py.

    def readFitsWithOptions(cls, filename, options):
        """Build an instance of this class with options.
 
        Parameters
        ----------
        filename : `str`
            Name of the file to read
        options : `PropertyList`
            Collection of metadata parameters
        """
        # To avoid problems since this is no longer an abstract method
        if cls is not StampsBase:
            raise NotImplementedError(
                f"Please implement specific FITS reader for class {cls}"
            )
 
        # Load metadata to get class
        metadata = afwFits.readMetadata(filename, hdu=0)
        type_name = metadata.get("STAMPCLS")
        if type_name is None:
            raise RuntimeError(
                f"No class name in file {filename}. Unable to instantiate correct"
                " stamps subclass. Is this an old version format Stamps file?"
            )
 
        # Import class and override `cls`
        stamp_type = doImport(type_name)
        cls = stamp_type
 
        return cls.readFitsWithOptions(filename, options)
 

writeFits()

def lsst.meas.algorithms.stamps.StampsBase.writeFits	(		self,
			filename
	)

Write this object to a file.

Parameters
----------
filename : `str`
    Name of file to write

Definition at line 363 of file stamps.py.

    def writeFits(self, filename):
        """Write this object to a file.
 
        Parameters
        ----------
        filename : `str`
            Name of file to write
        """
        self._refresh_metadata()
        type_name = get_full_type_name(self)
        writeFits(filename, self._stamps, self._metadata, type_name, self.use_mask, self.use_variance,
                  self.use_archive)
 

Member Data Documentation

use_archive

lsst.meas.algorithms.stamps.StampsBase.use_archive

Definition at line 310 of file stamps.py.

use_mask

lsst.meas.algorithms.stamps.StampsBase.use_mask

Definition at line 308 of file stamps.py.

use_variance

lsst.meas.algorithms.stamps.StampsBase.use_variance

Definition at line 309 of file stamps.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_algorithms/22.0.1-32-gf62ce7b1+aa4237961e/python/lsst/meas/algorithms/stamps.py