lsst.meas.algorithms.defects.Defects Class Reference

Inheritance diagram for lsst.meas.algorithms.defects.Defects:

Public Member Functions
def	__init__ (self, defectList=None, metadata=None, *normalize_on_init=True)
def	__len__ (self)
def	__getitem__ (self, index)
def	__setitem__ (self, index, value)
def	__iter__ (self)
def	__delitem__ (self, index)
def	__eq__ (self, other)
def	__str__ (self)
def	bulk_update (self)
def	insert (self, index, value)
def	getMetadata (self)
def	setMetadata (self, metadata=None)
def	copy (self)
def	transpose (self)
def	maskPixels (self, maskedImage, maskName="BAD")
def	toFitsRegionTable (self)
def	writeFits (self, *args)
def	toSimpleTable (self)
def	writeText (self, filename)
def	fromTable (cls, table, normalize_on_init=True)
def	readFits (cls, *args, normalize_on_init=False)
def	readText (cls, filename, normalize_on_init=False)
def	readLsstDefectsFile (cls, filename, normalize_on_init=False)
def	fromFootprintList (cls, fpList)
def	fromMask (cls, maskedImage, maskName)

Detailed Description

Collection of `lsst.meas.algorithms.Defect`.

Parameters
----------
defectList : iterable of `lsst.meas.algorithms.Defect`
             or `lsst.geom.BoxI`, optional
    Collections of defects to apply to the image.
metadata : `lsst.daf.base.PropertyList`, optional
    Metadata to associate with the defects.  Will be copied and
    overwrite existing metadata, if any. If not supplied the existing
    metadata will be reset.
normalize_on_init : `bool`
    If True, normalization is applied to the defects in ``defectList`` to
    remove duplicates, eliminate overlaps, etc.

Notes
-----
Defects are stored within this collection in a "reduced" or "normalized"
form: rather than simply storing the bounding boxes which are added to the
collection, we eliminate overlaps and duplicates. This normalization
procedure may introduce overhead when adding many new defects; it may be
temporarily disabled using the `Defects.bulk_update` context manager if
necessary.

Definition at line 56 of file defects.py.

Constructor & Destructor Documentation

__init__()

def lsst.meas.algorithms.defects.Defects.__init__	(		self,
			defectList = None,
			metadata = None,
		*	normalize_on_init = True
	)

Definition at line 86 of file defects.py.

    def __init__(self, defectList=None, metadata=None, *, normalize_on_init=True):
        self._defects = []
 
        if defectList is not None:
            self._bulk_update = True
            for d in defectList:
                self.append(d)
        self._bulk_update = False
 
        if normalize_on_init:
            self._normalize()
 
        if metadata is not None:
            self._metadata = metadata
        else:
            self.setMetadata()
 

Member Function Documentation

__delitem__()

def lsst.meas.algorithms.defects.Defects.__delitem__	(		self,
			index
	)

Definition at line 150 of file defects.py.

    def __delitem__(self, index):
        del self._defects[index]
 

__eq__()

def lsst.meas.algorithms.defects.Defects.__eq__	(		self,
			other
	)

Compare if two `Defects` are equal.

Two `Defects` are equal if their bounding boxes are equal and in
the same order.  Metadata content is ignored.

Definition at line 153 of file defects.py.

    def __eq__(self, other):
        """Compare if two `Defects` are equal.
 
        Two `Defects` are equal if their bounding boxes are equal and in
        the same order.  Metadata content is ignored.
        """
        if not isinstance(other, self.__class__):
            return False
 
        # checking the bboxes with zip() only works if same length
        if len(self) != len(other):
            return False
 
        # Assume equal if bounding boxes are equal
        for d1, d2 in zip(self, other):
            if d1.getBBox() != d2.getBBox():
                return False
 
        return True
 

__getitem__()

def lsst.meas.algorithms.defects.Defects.__getitem__	(		self,
			index
	)

Definition at line 138 of file defects.py.

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

__iter__()

def lsst.meas.algorithms.defects.Defects.__iter__

(

self

)

Definition at line 147 of file defects.py.

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

__len__()

def lsst.meas.algorithms.defects.Defects.__len__

(

self

)

Definition at line 135 of file defects.py.

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

__setitem__()

def lsst.meas.algorithms.defects.Defects.__setitem__	(		self,
			index,
			value
	)

Can be given a `~lsst.meas.algorithms.Defect` or a `lsst.geom.BoxI`

Definition at line 141 of file defects.py.

    def __setitem__(self, index, value):
        """Can be given a `~lsst.meas.algorithms.Defect` or a `lsst.geom.BoxI`
        """
        self._defects[index] = self._check_value(value)
        self._normalize()
 

__str__()

def lsst.meas.algorithms.defects.Defects.__str__

(

self

)

Definition at line 173 of file defects.py.

    def __str__(self):
        return "Defects(" + ",".join(str(d.getBBox()) for d in self) + ")"
 

bulk_update()

def lsst.meas.algorithms.defects.Defects.bulk_update

(

self

)

Temporarily suspend normalization of the defect list.

Definition at line 207 of file defects.py.

    def bulk_update(self):
        """Temporarily suspend normalization of the defect list.
        """
        self._bulk_update = True
        try:
            yield
        finally:
            self._bulk_update = False
            self._normalize()
 

copy()

def lsst.meas.algorithms.defects.Defects.copy

(

self

)

Copy the defects to a new list, creating new defects from the
bounding boxes.

Returns
-------
new : `Defects`
    New list with new `Defect` entries.

Notes
-----
This is not a shallow copy in that new `Defect` instances are
created from the original bounding boxes.  It's also not a deep
copy since the bounding boxes are not recreated.

Definition at line 251 of file defects.py.

    def copy(self):
        """Copy the defects to a new list, creating new defects from the
        bounding boxes.
 
        Returns
        -------
        new : `Defects`
            New list with new `Defect` entries.
 
        Notes
        -----
        This is not a shallow copy in that new `Defect` instances are
        created from the original bounding boxes.  It's also not a deep
        copy since the bounding boxes are not recreated.
        """
        return self.__class__(d.getBBox() for d in self)
 

fromFootprintList()

def lsst.meas.algorithms.defects.Defects.fromFootprintList	(		cls,
			fpList
	)

Compute a defect list from a footprint list, optionally growing
the footprints.

Parameters
----------
fpList : `list` of `lsst.afw.detection.Footprint`
    Footprint list to process.

Returns
-------
defects : `Defects`
    List of defects.

Definition at line 777 of file defects.py.

    def fromFootprintList(cls, fpList):
        """Compute a defect list from a footprint list, optionally growing
        the footprints.
 
        Parameters
        ----------
        fpList : `list` of `lsst.afw.detection.Footprint`
            Footprint list to process.
 
        Returns
        -------
        defects : `Defects`
            List of defects.
        """
        # normalize_on_init is set to False to avoid recursively calling
        # fromMask/fromFootprintList in Defects.__init__.
        return cls(itertools.chain.from_iterable(lsst.afw.detection.footprintToBBoxList(fp)
                                                 for fp in fpList), normalize_on_init=False)
 

fromMask()

def lsst.meas.algorithms.defects.Defects.fromMask	(		cls,
			maskedImage,
			maskName
	)

Compute a defect list from a specified mask plane.

Parameters
----------
maskedImage : `lsst.afw.image.MaskedImage`
    Image to process.
maskName : `str` or `list`
    Mask plane name, or list of names to convert.

Returns
-------
defects : `Defects`
    Defect list constructed from masked pixels.

Definition at line 797 of file defects.py.

    def fromMask(cls, maskedImage, maskName):
        """Compute a defect list from a specified mask plane.
 
        Parameters
        ----------
        maskedImage : `lsst.afw.image.MaskedImage`
            Image to process.
        maskName : `str` or `list`
            Mask plane name, or list of names to convert.
 
        Returns
        -------
        defects : `Defects`
            Defect list constructed from masked pixels.
        """
        mask = maskedImage.getMask()
        thresh = lsst.afw.detection.Threshold(mask.getPlaneBitMask(maskName),
                                              lsst.afw.detection.Threshold.BITMASK)
        fpList = lsst.afw.detection.FootprintSet(mask, thresh).getFootprints()
        return cls.fromFootprintList(fpList)

fromTable()

def lsst.meas.algorithms.defects.Defects.fromTable	(		cls,
			table,
			normalize_on_init = True
	)

Construct a `Defects` from the contents of a
`~lsst.afw.table.BaseCatalog`.

Parameters
----------
table : `lsst.afw.table.BaseCatalog`
    Table with one row per defect.
normalize_on_init : `bool`, optional
    If `True`, normalization is applied to the defects listed in the
    table to remove duplicates, eliminate overlaps, etc. Otherwise
    the defects in the returned object exactly match those in the
    table.

Returns
-------
defects : `Defects`
    A `Defects` list.

Notes
-----
Two table formats are recognized.  The first is the
`FITS regions <https://fits.gsfc.nasa.gov/registry/region.html>`_
definition tabular format written by `toFitsRegionTable` where the
pixel origin is corrected from FITS 1-based to a 0-based origin.
The second is the legacy defects format using columns ``x0``, ``y0``
(bottom left hand pixel of box in 0-based coordinates), ``width``
and ``height``.

The FITS standard regions can only read BOX, POINT, or ROTBOX with
a zero degree rotation.

Definition at line 535 of file defects.py.

    def fromTable(cls, table, normalize_on_init=True):
        """Construct a `Defects` from the contents of a
        `~lsst.afw.table.BaseCatalog`.
 
        Parameters
        ----------
        table : `lsst.afw.table.BaseCatalog`
            Table with one row per defect.
        normalize_on_init : `bool`, optional
            If `True`, normalization is applied to the defects listed in the
            table to remove duplicates, eliminate overlaps, etc. Otherwise
            the defects in the returned object exactly match those in the
            table.
 
        Returns
        -------
        defects : `Defects`
            A `Defects` list.
 
        Notes
        -----
        Two table formats are recognized.  The first is the
        `FITS regions <https://fits.gsfc.nasa.gov/registry/region.html>`_
        definition tabular format written by `toFitsRegionTable` where the
        pixel origin is corrected from FITS 1-based to a 0-based origin.
        The second is the legacy defects format using columns ``x0``, ``y0``
        (bottom left hand pixel of box in 0-based coordinates), ``width``
        and ``height``.
 
        The FITS standard regions can only read BOX, POINT, or ROTBOX with
        a zero degree rotation.
        """
 
        defectList = []
 
        schema = table.getSchema()
 
        # Check schema to see which definitions we have
        if "X" in schema and "Y" in schema and "R" in schema and "SHAPE" in schema:
            # This is a FITS region style table
            isFitsRegion = True
 
            # Preselect the keys
            xKey = schema["X"].asKey()
            yKey = schema["Y"].asKey()
            shapeKey = schema["SHAPE"].asKey()
            rKey = schema["R"].asKey()
            rotangKey = schema["ROTANG"].asKey()
 
        elif "x0" in schema and "y0" in schema and "width" in schema and "height" in schema:
            # This is a classic LSST-style defect table
            isFitsRegion = False
 
            # Preselect the keys
            xKey = schema["x0"].asKey()
            yKey = schema["y0"].asKey()
            widthKey = schema["width"].asKey()
            heightKey = schema["height"].asKey()
 
        else:
            raise ValueError("Unsupported schema for defects extraction")
 
        for record in table:
 
            if isFitsRegion:
                # Coordinates can be arrays (some shapes in the standard
                # require this)
                # Correct for FITS 1-based origin
                xcen = cls._get_values(record[xKey]) - 1.0
                ycen = cls._get_values(record[yKey]) - 1.0
                shape = record[shapeKey].upper()
                if shape == "BOX":
                    box = lsst.geom.Box2I.makeCenteredBox(lsst.geom.Point2D(xcen, ycen),
                                                          lsst.geom.Extent2I(cls._get_values(record[rKey],
                                                                                             n=2)))
                elif shape == "POINT":
                    # Handle the case where we have an externally created
                    # FITS file.
                    box = lsst.geom.Point2I(xcen, ycen)
                elif shape == "ROTBOX":
                    # Astropy regions always writes ROTBOX
                    rotang = cls._get_values(record[rotangKey])
                    # We can support 0 or 90 deg
                    if math.isclose(rotang % 90.0, 0.0):
                        # Two values required
                        r = cls._get_values(record[rKey], n=2)
                        if math.isclose(rotang % 180.0, 0.0):
                            width = r[0]
                            height = r[1]
                        else:
                            width = r[1]
                            height = r[0]
                        box = lsst.geom.Box2I.makeCenteredBox(lsst.geom.Point2D(xcen, ycen),
                                                              lsst.geom.Extent2I(width, height))
                    else:
                        log.warning("Defect can not be defined using ROTBOX with non-aligned rotation angle")
                        continue
                else:
                    log.warning("Defect lists can only be defined using BOX or POINT not %s", shape)
                    continue
 
            else:
                # This is a classic LSST-style defect table
                box = lsst.geom.Box2I(lsst.geom.Point2I(record[xKey], record[yKey]),
                                      lsst.geom.Extent2I(record[widthKey], record[heightKey]))
 
            defectList.append(box)
 
        defects = cls(defectList, normalize_on_init=normalize_on_init)
        defects.setMetadata(table.getMetadata())
 
        # Once read, the schema headers are irrelevant
        metadata = defects.getMetadata()
        for k in (SCHEMA_NAME_KEY, SCHEMA_VERSION_KEY):
            if k in metadata:
                del metadata[k]
 
        return defects
 

getMetadata()

def lsst.meas.algorithms.defects.Defects.getMetadata

(

self

)

Retrieve metadata associated with these `Defects`.

Returns
-------
meta : `lsst.daf.base.PropertyList`
    Metadata. The returned `~lsst.daf.base.PropertyList` can be
    modified by the caller and the changes will be written to
    external files.

Definition at line 221 of file defects.py.

    def getMetadata(self):
        """Retrieve metadata associated with these `Defects`.
 
        Returns
        -------
        meta : `lsst.daf.base.PropertyList`
            Metadata. The returned `~lsst.daf.base.PropertyList` can be
            modified by the caller and the changes will be written to
            external files.
        """
        return self._metadata
 

insert()

def lsst.meas.algorithms.defects.Defects.insert	(		self,
			index,
			value
	)

Definition at line 217 of file defects.py.

    def insert(self, index, value):
        self._defects.insert(index, self._check_value(value))
        self._normalize()
 

maskPixels()

def lsst.meas.algorithms.defects.Defects.maskPixels	(		self,
			maskedImage,
			maskName = "BAD"
	)

Set mask plane based on these defects.

Parameters
----------
maskedImage : `lsst.afw.image.MaskedImage`
    Image to process.  Only the mask plane is updated.
maskName : str, optional
    Mask plane name to use.

Definition at line 285 of file defects.py.

    def maskPixels(self, maskedImage, maskName="BAD"):
        """Set mask plane based on these defects.
 
        Parameters
        ----------
        maskedImage : `lsst.afw.image.MaskedImage`
            Image to process.  Only the mask plane is updated.
        maskName : str, optional
            Mask plane name to use.
        """
        # mask bad pixels
        mask = maskedImage.getMask()
        bitmask = mask.getPlaneBitMask(maskName)
        for defect in self:
            bbox = defect.getBBox()
            lsst.afw.geom.SpanSet(bbox).clippedTo(mask.getBBox()).setMask(mask, bitmask)
 

readFits()

def lsst.meas.algorithms.defects.Defects.readFits	(		cls,
		*	args,
			normalize_on_init = False
	)

Read defect list from FITS table.

Parameters
----------
*args
    Arguments to be forwarded to
    `lsst.afw.table.BaseCatalog.readFits`.
normalize_on_init : `bool`, optional
    If `True`, normalization is applied to the defects read fom the
    file to remove duplicates, eliminate overlaps, etc. Otherwise
    the defects in the returned object exactly match those in the
    file.

Returns
-------
defects : `Defects`
    Defects read from a FITS table.

Definition at line 655 of file defects.py.

    def readFits(cls, *args, normalize_on_init=False):
        """Read defect list from FITS table.
 
        Parameters
        ----------
        *args
            Arguments to be forwarded to
            `lsst.afw.table.BaseCatalog.readFits`.
        normalize_on_init : `bool`, optional
            If `True`, normalization is applied to the defects read fom the
            file to remove duplicates, eliminate overlaps, etc. Otherwise
            the defects in the returned object exactly match those in the
            file.
 
        Returns
        -------
        defects : `Defects`
            Defects read from a FITS table.
        """
        table = lsst.afw.table.BaseCatalog.readFits(*args)
        return cls.fromTable(table, normalize_on_init=normalize_on_init)
 

readLsstDefectsFile()

def lsst.meas.algorithms.defects.Defects.readLsstDefectsFile	(		cls,
			filename,
			normalize_on_init = False
	)

Read defects information from a legacy LSST format text file.

Parameters
----------
filename : `str`
    Name of text file containing the defect information.
normalize_on_init : `bool`, optional
    If `True`, normalization is applied to the defects read fom the
    file to remove duplicates, eliminate overlaps, etc. Otherwise
    the defects in the returned object exactly match those in the
    file.

Returns
-------
defects : `Defects`
    The defects.

Notes
-----
These defect text files are used as the human readable definitions
of defects in calibration data definition repositories.  The format
is to use four columns defined as follows:

x0 : `int`
    X coordinate of bottom left corner of box.
y0 : `int`
    Y coordinate of bottom left corner of box.
width : `int`
    X extent of the box.
height : `int`
    Y extent of the box.

Files of this format were used historically to represent defects
in simple text form.  Use `Defects.readText` and `Defects.writeText`
to use the more modern format.

Definition at line 727 of file defects.py.

    def readLsstDefectsFile(cls, filename, normalize_on_init=False):
        """Read defects information from a legacy LSST format text file.
 
        Parameters
        ----------
        filename : `str`
            Name of text file containing the defect information.
        normalize_on_init : `bool`, optional
            If `True`, normalization is applied to the defects read fom the
            file to remove duplicates, eliminate overlaps, etc. Otherwise
            the defects in the returned object exactly match those in the
            file.
 
        Returns
        -------
        defects : `Defects`
            The defects.
 
        Notes
        -----
        These defect text files are used as the human readable definitions
        of defects in calibration data definition repositories.  The format
        is to use four columns defined as follows:
 
        x0 : `int`
            X coordinate of bottom left corner of box.
        y0 : `int`
            Y coordinate of bottom left corner of box.
        width : `int`
            X extent of the box.
        height : `int`
            Y extent of the box.
 
        Files of this format were used historically to represent defects
        in simple text form.  Use `Defects.readText` and `Defects.writeText`
        to use the more modern format.
        """
        # Use loadtxt so that ValueError is thrown if the file contains a
        # non-integer value. genfromtxt converts bad values to -1.
        defect_array = np.loadtxt(filename,
                                  dtype=[("x0", "int"), ("y0", "int"),
                                         ("x_extent", "int"), ("y_extent", "int")])
 
        defects = (lsst.geom.Box2I(lsst.geom.Point2I(row["x0"], row["y0"]),
                                   lsst.geom.Extent2I(row["x_extent"], row["y_extent"]))
                   for row in defect_array)
 
        return cls(defects, normalize_on_init=normalize_on_init)
 

readText()

def lsst.meas.algorithms.defects.Defects.readText	(		cls,
			filename,
			normalize_on_init = False
	)

Read defect list from standard format text table file.

Parameters
----------
filename : `str`
    Name of the file containing the defects definitions.
normalize_on_init : `bool`, optional
    If `True`, normalization is applied to the defects read fom the
    file to remove duplicates, eliminate overlaps, etc. Otherwise
    the defects in the returned object exactly match those in the
    file.

Returns
-------
defects : `Defects`
    Defects read from a FITS table.

Definition at line 678 of file defects.py.

    def readText(cls, filename, normalize_on_init=False):
        """Read defect list from standard format text table file.
 
        Parameters
        ----------
        filename : `str`
            Name of the file containing the defects definitions.
        normalize_on_init : `bool`, optional
            If `True`, normalization is applied to the defects read fom the
            file to remove duplicates, eliminate overlaps, etc. Otherwise
            the defects in the returned object exactly match those in the
            file.
 
        Returns
        -------
        defects : `Defects`
            Defects read from a FITS table.
        """
        with warnings.catch_warnings():
            # Squash warnings due to astropy failure to close files; we think
            # this is a real problem, but the warnings are even worse.
            # https://github.com/astropy/astropy/issues/8673
            warnings.filterwarnings("ignore", category=ResourceWarning, module="astropy.io.ascii")
            table = astropy.table.Table.read(filename)
 
        # Need to convert the Astropy table to afw table
        schema = lsst.afw.table.Schema()
        for colName in table.columns:
            schema.addField(colName, units=str(table[colName].unit),
                            type=table[colName].dtype.type)
 
        # Create AFW table that is required by fromTable()
        afwTable = lsst.afw.table.BaseCatalog(schema)
 
        afwTable.resize(len(table))
        for colName in table.columns:
            # String columns will fail -- currently we do not expect any
            afwTable[colName] = table[colName]
 
        # Copy in the metadata from the astropy table
        metadata = PropertyList()
        for k, v in table.meta.items():
            metadata[k] = v
        afwTable.setMetadata(metadata)
 
        # Extract defect information from the table itself
        return cls.fromTable(afwTable, normalize_on_init=normalize_on_init)
 

setMetadata()

def lsst.meas.algorithms.defects.Defects.setMetadata	(		self,
			metadata = None
	)

Store a copy of the supplied metadata with the defects.

Parameters
----------
metadata : `lsst.daf.base.PropertyList`, optional
    Metadata to associate with the defects.  Will be copied and
    overwrite existing metadata.  If not supplied the existing
    metadata will be reset.

Definition at line 233 of file defects.py.

    def setMetadata(self, metadata=None):
        """Store a copy of the supplied metadata with the defects.
 
        Parameters
        ----------
        metadata : `lsst.daf.base.PropertyList`, optional
            Metadata to associate with the defects.  Will be copied and
            overwrite existing metadata.  If not supplied the existing
            metadata will be reset.
        """
        if metadata is None:
            self._metadata = PropertyList()
        else:
            self._metadata = copy.copy(metadata)
 
        # Ensure that we have the obs type required by calibration ingest
        self._metadata["OBSTYPE"] = self._OBSTYPE
 

toFitsRegionTable()

def lsst.meas.algorithms.defects.Defects.toFitsRegionTable

(

self

)

Convert defect list to `~lsst.afw.table.BaseCatalog` using the
FITS region standard.

Returns
-------
table : `lsst.afw.table.BaseCatalog`
    Defects in tabular form.

Notes
-----
The table created uses the
`FITS regions <https://fits.gsfc.nasa.gov/registry/region.html>`_
definition tabular format.  The ``X`` and ``Y`` coordinates are
converted to FITS Physical coordinates that have origin pixel (1, 1)
rather than the (0, 0) used in LSST software.

Definition at line 302 of file defects.py.

    def toFitsRegionTable(self):
        """Convert defect list to `~lsst.afw.table.BaseCatalog` using the
        FITS region standard.
 
        Returns
        -------
        table : `lsst.afw.table.BaseCatalog`
            Defects in tabular form.
 
        Notes
        -----
        The table created uses the
        `FITS regions <https://fits.gsfc.nasa.gov/registry/region.html>`_
        definition tabular format.  The ``X`` and ``Y`` coordinates are
        converted to FITS Physical coordinates that have origin pixel (1, 1)
        rather than the (0, 0) used in LSST software.
        """
 
        nrows = len(self._defects)
 
        schema = lsst.afw.table.Schema()
        x = schema.addField("X", type="D", units="pix", doc="X coordinate of center of shape")
        y = schema.addField("Y", type="D", units="pix", doc="Y coordinate of center of shape")
        shape = schema.addField("SHAPE", type="String", size=16, doc="Shape defined by these values")
        r = schema.addField("R", type="ArrayD", size=2, units="pix", doc="Extents")
        rotang = schema.addField("ROTANG", type="D", units="deg", doc="Rotation angle")
        component = schema.addField("COMPONENT", type="I", doc="Index of this region")
        table = lsst.afw.table.BaseCatalog(schema)
        table.resize(nrows)
 
        if nrows:
            # Adding entire columns is more efficient than adding
            # each element separately
            xCol = []
            yCol = []
            rCol = []
 
            for i, defect in enumerate(self._defects):
                box = defect.getBBox()
                center = box.getCenter()
                # Correct for the FITS 1-based offset
                xCol.append(center.getX() + 1.0)
                yCol.append(center.getY() + 1.0)
 
                width = box.width
                height = box.height
 
                if width == 1 and height == 1:
                    # Call this a point
                    shapeType = "POINT"
                else:
                    shapeType = "BOX"
 
                # Strings have to be added per row
                table[i][shape] = shapeType
 
                rCol.append(np.array([width, height], dtype=np.float64))
 
            # Assign the columns
            table[x] = np.array(xCol, dtype=np.float64)
            table[y] = np.array(yCol, dtype=np.float64)
 
            table[r] = np.array(rCol)
            table[rotang] = np.zeros(nrows, dtype=np.float64)
            table[component] = np.arange(nrows)
 
        # Set some metadata in the table (force OBSTYPE to exist)
        metadata = copy.copy(self.getMetadata())
        metadata["OBSTYPE"] = self._OBSTYPE
        metadata[SCHEMA_NAME_KEY] = "FITS Region"
        metadata[SCHEMA_VERSION_KEY] = 1
        table.setMetadata(metadata)
 
        return table
 

toSimpleTable()

def lsst.meas.algorithms.defects.Defects.toSimpleTable

(

self

)

Convert defects to a simple table form that we use to write
to text files.

Returns
-------
table : `lsst.afw.table.BaseCatalog`
    Defects in simple tabular form.

Notes
-----
These defect tables are used as the human readable definitions
of defects in calibration data definition repositories.  The format
is to use four columns defined as follows:

x0 : `int`
    X coordinate of bottom left corner of box.
y0 : `int`
    Y coordinate of bottom left corner of box.
width : `int`
    X extent of the box.
height : `int`
    Y extent of the box.

Definition at line 397 of file defects.py.

    def toSimpleTable(self):
        """Convert defects to a simple table form that we use to write
        to text files.
 
        Returns
        -------
        table : `lsst.afw.table.BaseCatalog`
            Defects in simple tabular form.
 
        Notes
        -----
        These defect tables are used as the human readable definitions
        of defects in calibration data definition repositories.  The format
        is to use four columns defined as follows:
 
        x0 : `int`
            X coordinate of bottom left corner of box.
        y0 : `int`
            Y coordinate of bottom left corner of box.
        width : `int`
            X extent of the box.
        height : `int`
            Y extent of the box.
        """
        schema = lsst.afw.table.Schema()
        x = schema.addField("x0", type="I", units="pix",
                            doc="X coordinate of bottom left corner of box")
        y = schema.addField("y0", type="I", units="pix",
                            doc="Y coordinate of bottom left corner of box")
        width = schema.addField("width", type="I", units="pix",
                                doc="X extent of box")
        height = schema.addField("height", type="I", units="pix",
                                 doc="Y extent of box")
        table = lsst.afw.table.BaseCatalog(schema)
 
        nrows = len(self._defects)
        table.resize(nrows)
 
        if nrows:
 
            xCol = []
            yCol = []
            widthCol = []
            heightCol = []
 
            for defect in self._defects:
                box = defect.getBBox()
                xCol.append(box.getBeginX())
                yCol.append(box.getBeginY())
                widthCol.append(box.getWidth())
                heightCol.append(box.getHeight())
 
            table[x] = np.array(xCol, dtype=np.int64)
            table[y] = np.array(yCol, dtype=np.int64)
            table[width] = np.array(widthCol, dtype=np.int64)
            table[height] = np.array(heightCol, dtype=np.int64)
 
        # Set some metadata in the table (force OBSTYPE to exist)
        metadata = copy.copy(self.getMetadata())
        metadata["OBSTYPE"] = self._OBSTYPE
        metadata[SCHEMA_NAME_KEY] = "Simple"
        metadata[SCHEMA_VERSION_KEY] = 1
        table.setMetadata(metadata)
 
        return table
 

transpose()

def lsst.meas.algorithms.defects.Defects.transpose

(

self

)

Make a transposed copy of this defect list.

Returns
-------
retDefectList : `Defects`
    Transposed list of defects.

Definition at line 268 of file defects.py.

    def transpose(self):
        """Make a transposed copy of this defect list.
 
        Returns
        -------
        retDefectList : `Defects`
            Transposed list of defects.
        """
        retDefectList = self.__class__()
        for defect in self:
            bbox = defect.getBBox()
            dimensions = bbox.getDimensions()
            nbbox = lsst.geom.Box2I(lsst.geom.Point2I(bbox.getMinY(), bbox.getMinX()),
                                    lsst.geom.Extent2I(dimensions[1], dimensions[0]))
            retDefectList.append(nbbox)
        return retDefectList
 

writeFits()

def lsst.meas.algorithms.defects.Defects.writeFits	(		self,
		*	args
	)

Write defect list to FITS.

Parameters
----------
*args
    Arguments to be forwarded to
    `lsst.afw.table.BaseCatalog.writeFits`.

Definition at line 377 of file defects.py.

    def writeFits(self, *args):
        """Write defect list to FITS.
 
        Parameters
        ----------
        *args
            Arguments to be forwarded to
            `lsst.afw.table.BaseCatalog.writeFits`.
        """
        table = self.toFitsRegionTable()
 
        # Add some additional headers useful for tracking purposes
        metadata = table.getMetadata()
        now = datetime.datetime.utcnow()
        metadata["DATE"] = now.isoformat()
        metadata["CALIB_CREATION_DATE"] = now.strftime("%Y-%m-%d")
        metadata["CALIB_CREATION_TIME"] = now.strftime("%T %Z").strip()
 
        table.writeFits(*args)
 

writeText()

def lsst.meas.algorithms.defects.Defects.writeText	(		self,
			filename
	)

Write the defects out to a text file with the specified name.

Parameters
----------
filename : `str`
    Name of the file to write.  The file extension ".ecsv" will
    always be used.

Returns
-------
used : `str`
    The name of the file used to write the data (which may be
    different from the supplied name given the change to file
    extension).

Notes
-----
The file is written to ECSV format and will include any metadata
associated with the `Defects`.

Definition at line 463 of file defects.py.

    def writeText(self, filename):
        """Write the defects out to a text file with the specified name.
 
        Parameters
        ----------
        filename : `str`
            Name of the file to write.  The file extension ".ecsv" will
            always be used.
 
        Returns
        -------
        used : `str`
            The name of the file used to write the data (which may be
            different from the supplied name given the change to file
            extension).
 
        Notes
        -----
        The file is written to ECSV format and will include any metadata
        associated with the `Defects`.
        """
 
        # Using astropy table is the easiest way to serialize to ecsv
        afwTable = self.toSimpleTable()
        table = afwTable.asAstropy()
 
        metadata = afwTable.getMetadata()
        now = datetime.datetime.utcnow()
        metadata["DATE"] = now.isoformat()
        metadata["CALIB_CREATION_DATE"] = now.strftime("%Y-%m-%d")
        metadata["CALIB_CREATION_TIME"] = now.strftime("%T %Z").strip()
 
        table.meta = metadata.toDict()
 
        # Force file extension to .ecsv
        path, ext = os.path.splitext(filename)
        filename = path + ".ecsv"
        table.write(filename, format="ascii.ecsv")
        return filename
 

---

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

• /j/snowflake/release/lsstsw/stack/cb4e2dc/Linux64/meas_algorithms/20.0.0-11-gd9dafd18+74fdb5a06a/python/lsst/meas/algorithms/defects.py