lsst.meas.algorithms.brightStarStamps.BrightStarStamps Class Reference

Inheritance diagram for lsst.meas.algorithms.brightStarStamps.BrightStarStamps:

Public Member Functions
def	__init__ (self, starStamps, innerRadius=None, outerRadius=None, nb90Rots=None, metadata=None, use_mask=True, use_variance=False, use_archive=False)
def	initAndNormalize (cls, starStamps, innerRadius, outerRadius, nb90Rots=None, metadata=None, use_mask=True, use_variance=False, use_archive=False, imCenter=None, discardNanFluxObjects=True, statsControl=afwMath.StatisticsControl(), statsFlag=afwMath.stringToStatisticsProperty("MEAN"), badMaskPlanes=('BAD', 'SAT', 'NO_DATA'))
def	readFits (cls, filename)
def	readFitsWithOptions (cls, filename, options)
def	append (self, item, innerRadius=None, outerRadius=None)
def	extend (self, bss)
def	getMagnitudes (self)
def	getGaiaIds (self)
def	getAnnularFluxes (self)
def	selectByMag (self, magMin=None, magMax=None)
def	getPositions (self)
def	append (self, item)
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
	normalized
	nb90Rots
	use_mask
	use_variance
	use_archive

Detailed Description

Collection of bright star stamps and associated metadata.

Parameters
----------
starStamps : `collections.abc.Sequence` [`BrightStarStamp`]
    Sequence of star stamps. Cannot contain both normalized and
    unnormalized stamps.
innerRadius : `int`, optional
    Inner radius value, in pixels. This and ``outerRadius`` define the
    annulus used to compute the ``"annularFlux"`` values within each
    ``starStamp``. Must be provided if ``normalize`` is True.
outerRadius : `int`, optional
    Outer radius value, in pixels. This and ``innerRadius`` define the
    annulus used to compute the ``"annularFlux"`` values within each
    ``starStamp``. Must be provided if ``normalize`` is True.
nb90Rots : `int`, optional
    Number of 90 degree rotations required to compensate for detector
    orientation.
metadata : `lsst.daf.base.PropertyList`, optional
    Metadata associated with the bright stars.
use_mask : `bool`
    If `True` read and write mask data. Default `True`.
use_variance : `bool`
    If ``True`` read and write variance data. Default ``False``.
use_archive : `bool`
    If ``True`` read and write an Archive that contains a Persistable
    associated with each stamp. In the case of bright stars, this is
    usually a ``TransformPoint2ToPoint2``, used to warp each stamp
    to the same pixel grid before stacking.

Raises
------
ValueError
    Raised if one of the star stamps provided does not contain the
    required keys.
AttributeError
    Raised if there is a mix-and-match of normalized and unnormalized
    stamps, stamps normalized with different annulus definitions, or if
    stamps are to be normalized but annular radii were not provided.


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 151 of file brightStarStamps.py.

Constructor & Destructor Documentation

__init__()

def lsst.meas.algorithms.brightStarStamps.BrightStarStamps.__init__	(		self,
			starStamps,
			innerRadius = None,
			outerRadius = None,
			nb90Rots = None,
			metadata = None,
			use_mask = True,
			use_variance = False,
			use_archive = False
	)

Definition at line 201 of file brightStarStamps.py.

                 metadata=None, use_mask=True, use_variance=False, use_archive=False):
        super().__init__(starStamps, metadata, use_mask, use_variance, use_archive)
        # Ensure stamps contain a flux measurement if and only if they are
        # already expected to be normalized
        self._checkNormalization(False, innerRadius, outerRadius)
        self._innerRadius, self._outerRadius = innerRadius, outerRadius
        if innerRadius is not None and outerRadius is not None:
            self.normalized = True
        else:
            self.normalized = False
        self.nb90Rots = nb90Rots
 

Member Function Documentation

__getitem__()

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

inherited

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 )

inherited

Definition at line 382 of file stamps.py.

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

__len__()

def lsst.meas.algorithms.stamps.StampsBase.__len__ (   self )

inherited

Definition at line 376 of file stamps.py.

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

append() [1/2]

def lsst.meas.algorithms.stamps.Stamps.append (   self,   item  )

inherited

Add an additional stamp.

Parameters
----------
item : `Stamp`
    Stamp object to append.

Definition at line 419 of file stamps.py.

    def append(self, item):
        """Add an additional stamp.
 
        Parameters
        ----------
        item : `Stamp`
            Stamp object to append.
        """
        if not isinstance(item, Stamp):
            raise ValueError("Objects added must be a Stamp object.")
        self._stamps.append(item)
        return None
 

append() [2/2]

def lsst.meas.algorithms.brightStarStamps.BrightStarStamps.append	(		self,
			item,
			innerRadius = None,
			outerRadius = None
	)

Add an additional bright star stamp.

Parameters
----------
item : `BrightStarStamp`
    Bright star stamp to append.
innerRadius : `int`, optional
    Inner radius value, in pixels. This and ``outerRadius`` define the
    annulus used to compute the ``"annularFlux"`` values within each
    ``BrightStarStamp``.
outerRadius : `int`, optional
    Outer radius value, in pixels. This and ``innerRadius`` define the
    annulus used to compute the ``"annularFlux"`` values within each
    ``BrightStarStamp``.

Definition at line 364 of file brightStarStamps.py.

    def append(self, item, innerRadius=None, outerRadius=None):
        """Add an additional bright star stamp.
 
        Parameters
        ----------
        item : `BrightStarStamp`
            Bright star stamp to append.
        innerRadius : `int`, optional
            Inner radius value, in pixels. This and ``outerRadius`` define the
            annulus used to compute the ``"annularFlux"`` values within each
            ``BrightStarStamp``.
        outerRadius : `int`, optional
            Outer radius value, in pixels. This and ``innerRadius`` define the
            annulus used to compute the ``"annularFlux"`` values within each
            ``BrightStarStamp``.
        """
        if not isinstance(item, BrightStarStamp):
            raise ValueError(f"Can only add instances of BrightStarStamp, got {type(item)}.")
        if (item.annularFlux is None) == self.normalized:
            raise AttributeError("Trying to append an unnormalized stamp to a normalized BrightStarStamps "
                                 "instance, or vice-versa.")
        else:
            self._checkRadius(innerRadius, outerRadius)
        self._stamps.append(item)
        return None
 

extend()

def lsst.meas.algorithms.brightStarStamps.BrightStarStamps.extend	(		self,
			bss
	)

Extend BrightStarStamps instance by appending elements from another
instance.

Parameters
----------
bss : `BrightStarStamps`
    Other instance to concatenate.

Reimplemented from lsst.meas.algorithms.stamps.Stamps.

Definition at line 390 of file brightStarStamps.py.

    def extend(self, bss):
        """Extend BrightStarStamps instance by appending elements from another
        instance.
 
        Parameters
        ----------
        bss : `BrightStarStamps`
            Other instance to concatenate.
        """
        if not isinstance(bss, BrightStarStamps):
            raise ValueError('Can only extend with a BrightStarStamps object.  '
                             f'Got {type(bss)}.')
        self._checkRadius(bss._innerRadius, bss._outerRadius)
        self._stamps += bss._stamps
 

getAnnularFluxes()

def lsst.meas.algorithms.brightStarStamps.BrightStarStamps.getAnnularFluxes

(

self

)

Retrieve normalization factors for each star.

These are computed by integrating the flux in annulus centered on the
bright star, far enough from center to be beyond most severe ghosts and
saturation. The inner and outer radii that define the annulus can be
recovered from the metadata.

Returns
-------
annularFluxes : `list` [`float`]

Definition at line 423 of file brightStarStamps.py.

    def getAnnularFluxes(self):
        """Retrieve normalization factors for each star.
 
        These are computed by integrating the flux in annulus centered on the
        bright star, far enough from center to be beyond most severe ghosts and
        saturation. The inner and outer radii that define the annulus can be
        recovered from the metadata.
 
        Returns
        -------
        annularFluxes : `list` [`float`]
        """
        return [stamp.annularFlux for stamp in self._stamps]
 

getArchiveElements()

def lsst.meas.algorithms.stamps.StampsBase.getArchiveElements (   self )

inherited

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]
 

getGaiaIds()

def lsst.meas.algorithms.brightStarStamps.BrightStarStamps.getGaiaIds

(

self

)

Retrieve Gaia IDs for each star.

Returns
-------
gaiaIds : `list` [`int`]

Definition at line 414 of file brightStarStamps.py.

    def getGaiaIds(self):
        """Retrieve Gaia IDs for each star.
 
        Returns
        -------
        gaiaIds : `list` [`int`]
        """
        return [stamp.gaiaId for stamp in self._stamps]
 

getMagnitudes()

def lsst.meas.algorithms.brightStarStamps.BrightStarStamps.getMagnitudes

(

self

)

Retrieve Gaia G magnitudes for each star.

Returns
-------
gaiaGMags : `list` [`float`]

Definition at line 405 of file brightStarStamps.py.

    def getMagnitudes(self):
        """Retrieve Gaia G magnitudes for each star.
 
        Returns
        -------
        gaiaGMags : `list` [`float`]
        """
        return [stamp.gaiaGMag for stamp in self._stamps]
 

getMaskedImages()

def lsst.meas.algorithms.stamps.StampsBase.getMaskedImages (   self )

inherited

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]
 

getPositions()

def lsst.meas.algorithms.stamps.Stamps.getPositions (   self )

inherited

Definition at line 416 of file stamps.py.

    def getPositions(self):
        return [s.position for s in self._stamps]
 

initAndNormalize()

def lsst.meas.algorithms.brightStarStamps.BrightStarStamps.initAndNormalize	(		cls,
			starStamps,
			innerRadius,
			outerRadius,
			nb90Rots = None,
			metadata = None,
			use_mask = True,
			use_variance = False,
			use_archive = False,
			imCenter = None,
			discardNanFluxObjects = True,
			statsControl = afwMath.StatisticsControl(),
			statsFlag = afwMath.stringToStatisticsProperty("MEAN"),
			badMaskPlanes = ('BAD', 'SAT', 'NO_DATA')
	)

Normalize a set of bright star stamps and initialize a
BrightStarStamps instance.

Since the center of bright stars are saturated and/or heavily affected
by ghosts, we measure their flux in an annulus with a large enough
inner radius to avoid the most severe ghosts and contain enough
non-saturated pixels.

Parameters
----------
starStamps : `collections.abc.Sequence` [`BrightStarStamp`]
    Sequence of star stamps. Cannot contain both normalized and
    unnormalized stamps.
innerRadius : `int`
    Inner radius value, in pixels. This and ``outerRadius`` define the
    annulus used to compute the ``"annularFlux"`` values within each
    ``starStamp``.
outerRadius : `int`
    Outer radius value, in pixels. This and ``innerRadius`` define the
    annulus used to compute the ``"annularFlux"`` values within each
    ``starStamp``.
nb90Rots : `int`, optional
    Number of 90 degree rotations required to compensate for detector
    orientation.
metadata : `lsst.daf.base.PropertyList`, optional
    Metadata associated with the bright stars.
use_mask : `bool`
    If `True` read and write mask data. Default `True`.
use_variance : `bool`
    If ``True`` read and write variance data. Default ``False``.
use_archive : `bool`
    If ``True`` read and write an Archive that contains a Persistable
    associated with each stamp. In the case of bright stars, this is
    usually a ``TransformPoint2ToPoint2``, used to warp each stamp
    to the same pixel grid before stacking.
imCenter : `collections.abc.Sequence`, optional
    Center of the object, in pixels. If not provided, the center of the
    first stamp's pixel grid will be used.
discardNanFluxObjects : `bool`
    Whether objects with NaN annular flux should be discarded.
    If False, these objects will not be normalized.
statsControl : `lsst.afw.math.statistics.StatisticsControl`, optional
    StatisticsControl to be used when computing flux over all pixels
    within the annulus.
statsFlag : `lsst.afw.math.statistics.Property`, optional
    statsFlag to be passed on to ``afwMath.makeStatistics`` to compute
    annularFlux. Defaults to a simple MEAN.
badMaskPlanes : `collections.abc.Collection` [`str`]
    Collection of mask planes to ignore when computing annularFlux.

Raises
------
ValueError
    Raised if one of the star stamps provided does not contain the
    required keys.
AttributeError
    Raised if there is a mix-and-match of normalized and unnormalized
    stamps, stamps normalized with different annulus definitions, or if
    stamps are to be normalized but annular radii were not provided.

Definition at line 215 of file brightStarStamps.py.

                         badMaskPlanes=('BAD', 'SAT', 'NO_DATA')):
        """Normalize a set of bright star stamps and initialize a
        BrightStarStamps instance.
 
        Since the center of bright stars are saturated and/or heavily affected
        by ghosts, we measure their flux in an annulus with a large enough
        inner radius to avoid the most severe ghosts and contain enough
        non-saturated pixels.
 
        Parameters
        ----------
        starStamps : `collections.abc.Sequence` [`BrightStarStamp`]
            Sequence of star stamps. Cannot contain both normalized and
            unnormalized stamps.
        innerRadius : `int`
            Inner radius value, in pixels. This and ``outerRadius`` define the
            annulus used to compute the ``"annularFlux"`` values within each
            ``starStamp``.
        outerRadius : `int`
            Outer radius value, in pixels. This and ``innerRadius`` define the
            annulus used to compute the ``"annularFlux"`` values within each
            ``starStamp``.
        nb90Rots : `int`, optional
            Number of 90 degree rotations required to compensate for detector
            orientation.
        metadata : `lsst.daf.base.PropertyList`, optional
            Metadata associated with the bright stars.
        use_mask : `bool`
            If `True` read and write mask data. Default `True`.
        use_variance : `bool`
            If ``True`` read and write variance data. Default ``False``.
        use_archive : `bool`
            If ``True`` read and write an Archive that contains a Persistable
            associated with each stamp. In the case of bright stars, this is
            usually a ``TransformPoint2ToPoint2``, used to warp each stamp
            to the same pixel grid before stacking.
        imCenter : `collections.abc.Sequence`, optional
            Center of the object, in pixels. If not provided, the center of the
            first stamp's pixel grid will be used.
        discardNanFluxObjects : `bool`
            Whether objects with NaN annular flux should be discarded.
            If False, these objects will not be normalized.
        statsControl : `lsst.afw.math.statistics.StatisticsControl`, optional
            StatisticsControl to be used when computing flux over all pixels
            within the annulus.
        statsFlag : `lsst.afw.math.statistics.Property`, optional
            statsFlag to be passed on to ``afwMath.makeStatistics`` to compute
            annularFlux. Defaults to a simple MEAN.
        badMaskPlanes : `collections.abc.Collection` [`str`]
            Collection of mask planes to ignore when computing annularFlux.
 
        Raises
        ------
        ValueError
            Raised if one of the star stamps provided does not contain the
            required keys.
        AttributeError
            Raised if there is a mix-and-match of normalized and unnormalized
            stamps, stamps normalized with different annulus definitions, or if
            stamps are to be normalized but annular radii were not provided.
        """
        if imCenter is None:
            stampSize = starStamps[0].stamp_im.getDimensions()
            imCenter = stampSize[0]//2, stampSize[1]//2
        # Create SpanSet of annulus
        outerCircle = afwGeom.SpanSet.fromShape(outerRadius, afwGeom.Stencil.CIRCLE, offset=imCenter)
        innerCircle = afwGeom.SpanSet.fromShape(innerRadius, afwGeom.Stencil.CIRCLE, offset=imCenter)
        annulus = outerCircle.intersectNot(innerCircle)
        # Initialize (unnormalized) brightStarStamps instance
        bss = cls(starStamps, innerRadius=None, outerRadius=None, nb90Rots=nb90Rots,
                  metadata=metadata, use_mask=use_mask,
                  use_variance=use_variance, use_archive=use_archive)
        # Ensure no stamps had already been normalized
        bss._checkNormalization(True, innerRadius, outerRadius)
        bss._innerRadius, bss._outerRadius = innerRadius, outerRadius
        # Apply normalization
        for j, stamp in enumerate(bss._stamps):
            try:
                stamp.measureAndNormalize(annulus, statsControl=statsControl, statsFlag=statsFlag,
                                          badMaskPlanes=badMaskPlanes)
            except RuntimeError:
                # Optionally keep NaN flux objects, for bookkeeping purposes,
                # and to avoid having to re-find and redo the preprocessing
                # steps needed before bright stars can be subtracted.
                if discardNanFluxObjects:
                    bss._stamps.pop(j)
                else:
                    stamp.annularFlux = np.nan
        bss.normalized = True
        return bss
 

metadata()

def lsst.meas.algorithms.stamps.StampsBase.metadata (   self )

inherited

Definition at line 406 of file stamps.py.

    def metadata(self):
        return self._metadata
 
 

readFits()

def lsst.meas.algorithms.brightStarStamps.BrightStarStamps.readFits	(		cls,
			filename
	)

Build an instance of this class from a file.

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

Reimplemented from lsst.meas.algorithms.stamps.Stamps.

Definition at line 332 of file brightStarStamps.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.brightStarStamps.BrightStarStamps.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 from lsst.meas.algorithms.stamps.Stamps.

Definition at line 343 of file brightStarStamps.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
        """
        stamps, metadata = readFitsWithOptions(filename, BrightStarStamp.factory, options)
        nb90Rots = metadata["NB_90_ROTS"] if "NB_90_ROTS" in metadata else None
        if metadata["NORMALIZED"]:
            return cls(stamps,
                       innerRadius=metadata["INNER_RADIUS"], outerRadius=metadata["OUTER_RADIUS"],
                       nb90Rots=nb90Rots, metadata=metadata, use_mask=metadata['HAS_MASK'],
                       use_variance=metadata['HAS_VARIANCE'], use_archive=metadata['HAS_ARCHIVE'])
        else:
            return cls(stamps, nb90Rots=nb90Rots, metadata=metadata, use_mask=metadata['HAS_MASK'],
                       use_variance=metadata['HAS_VARIANCE'], use_archive=metadata['HAS_ARCHIVE'])
 

selectByMag()

def lsst.meas.algorithms.brightStarStamps.BrightStarStamps.selectByMag	(		self,
			magMin = None,
			magMax = None
	)

Return the subset of bright star stamps for objects with specified
magnitude cuts (in Gaia G).

Parameters
----------
magMin : `float`, optional
    Keep only stars fainter than this value.
magMax : `float`, optional
    Keep only stars brighter than this value.

Definition at line 437 of file brightStarStamps.py.

    def selectByMag(self, magMin=None, magMax=None):
        """Return the subset of bright star stamps for objects with specified
        magnitude cuts (in Gaia G).
 
        Parameters
        ----------
        magMin : `float`, optional
            Keep only stars fainter than this value.
        magMax : `float`, optional
            Keep only stars brighter than this value.
        """
        subset = [stamp for stamp in self._stamps
                  if (magMin is None or stamp.gaiaGMag > magMin)
                  and (magMax is None or stamp.gaiaGMag < magMax)]
        # This is an optimization to save looping over the init argument when
        # it is already guaranteed to be the correct type
        instance = BrightStarStamps((),
                                    innerRadius=self._innerRadius, outerRadius=self._outerRadius,
                                    metadata=self._metadata)
        instance._stamps = subset
        return instance
 

writeFits()

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

inherited

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

nb90Rots

lsst.meas.algorithms.brightStarStamps.BrightStarStamps.nb90Rots

Definition at line 212 of file brightStarStamps.py.

normalized

lsst.meas.algorithms.brightStarStamps.BrightStarStamps.normalized

Definition at line 209 of file brightStarStamps.py.

use_archive

lsst.meas.algorithms.stamps.StampsBase.use_archive

inherited

Definition at line 310 of file stamps.py.

use_mask

lsst.meas.algorithms.stamps.StampsBase.use_mask

inherited

Definition at line 308 of file stamps.py.

use_variance

lsst.meas.algorithms.stamps.StampsBase.use_variance

inherited

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/brightStarStamps.py