lsst::meas::base::PixelFlagsAlgorithm Class Reference

A measurement algorithm that gets mask bits from the exposure and sets flag bits to summarize which bits are set within a source's footprint. More...

#include <PixelFlags.h>

Inheritance diagram for lsst::meas::base::PixelFlagsAlgorithm:

Public Types
typedef PixelFlagsControl	Control
	A typedef to the Control object for this algorithm, defined above.
typedef std::map< std::string, afw::table::Key< afw::table::Flag > >	KeyMap

Public Member Functions
	PixelFlagsAlgorithm (Control const &ctrl, std::string const &name, afw::table::Schema &schema)
virtual void	measure (afw::table::SourceRecord &measRecord, afw::image::Exposure< float > const &exposure) const
	Called to measure a single child source in an image.
virtual void	fail (afw::table::SourceRecord &measRecord, MeasurementError *error=nullptr) const
	Handle an exception thrown by the current algorithm by setting flags in the given record.
void	measureForced (afw::table::SourceRecord &measRecord, afw::image::Exposure< float > const &exposure, afw::table::SourceRecord const &refRecord, afw::geom::SkyWcs const &refWcs) const override
	Called to measure a single child source in an image.
void	measureNForced (afw::table::SourceCatalog const &measCat, afw::image::Exposure< float > const &exposure, afw::table::SourceCatalog const &refRecord, afw::geom::SkyWcs const &refWcs) const override
	Called to simultaneously measure all children in a deblend family, in a single image.
virtual void	measureN (afw::table::SourceCatalog const &measCat, afw::image::Exposure< float > const &exposure) const
	Called to simultaneously measure all children in a deblend family, in a single image.
std::string	getLogName () const

Protected Attributes
std::string	_logName

Detailed Description

A measurement algorithm that gets mask bits from the exposure and sets flag bits to summarize which bits are set within a source's footprint.

Definition at line 64 of file PixelFlags.h.

Member Typedef Documentation

Control

typedef PixelFlagsControl lsst::meas::base::PixelFlagsAlgorithm::Control

A typedef to the Control object for this algorithm, defined above.

The control object contains the configuration parameters for this algorithm.

Definition at line 68 of file PixelFlags.h.

KeyMap

typedef std::map<std::string, afw::table::Key<afw::table::Flag> > lsst::meas::base::PixelFlagsAlgorithm::KeyMap

Definition at line 77 of file PixelFlags.h.

Constructor & Destructor Documentation

PixelFlagsAlgorithm()

lsst::meas::base::PixelFlagsAlgorithm::PixelFlagsAlgorithm	(	Control const &	ctrl,
		std::string const &	name,
		afw::table::Schema &	schema )

Definition at line 99 of file PixelFlags.cc.

        : _ctrl(ctrl) {
    // Add generic keys first, which don't correspond to specific mask planes
    _generalFailureKey = schema.addField<afw::table::Flag>(
            name + "_flag", "General failure flag, set if anything went wrong setting flags.");
    _offImageKey =
            schema.addField<afw::table::Flag>(name + "_flag" + "_offimage", "Source center is off image");
    // Set all the flags that correspond to mask planes anywhere in the footprint
    _anyKeys["EDGE"] = schema.addField<afw::table::Flag>(
            name + "_flag_edge",
            "Pixel in source outside usable exposure region (masked EDGE or centroid off image).");
    _anyKeys["NO_DATA"] = schema.addField<afw::table::Flag>(name + "_flag_nodata",
                                                            "NO_DATA pixel in the source footprint.");
    _anyKeys["INTRP"] = schema.addField<afw::table::Flag>(name + "_flag_interpolated",
                                                          "Interpolated pixel in the Source footprint");
    _anyKeys["SAT"] = schema.addField<afw::table::Flag>(name + "_flag_saturated",
                                                        "Saturated pixel in the Source footprint");
    _anyKeys["CR"] =
            schema.addField<afw::table::Flag>(name + "_flag_cr", "Cosmic ray in the Source footprint");
    _anyKeys["BAD"] =
            schema.addField<afw::table::Flag>(name + "_flag_bad", "Bad pixel in the Source footprint");
    _anyKeys["SUSPECT"] = schema.addField<afw::table::Flag>(name + "_flag_suspect",
                                                            "Source's footprint includes suspect pixels");
    // Flags that correspond to mask bits which are set anywhere in the 3x3 central region of the object.
    _centerKeys["EDGE"] = schema.addField<afw::table::Flag>(
            name + "_flag_edgeCenter", "EDGE pixel in the 3x3 region around the centroid.");
    _centerKeys["NO_DATA"] = schema.addField<afw::table::Flag>(
            name + "_flag_nodataCenter", "NO_DATA pixel in the 3x3 region around the centroid.");
    _centerKeys["INTRP"] = schema.addField<afw::table::Flag>(
            name + "_flag_interpolatedCenter", "Interpolated pixel in the 3x3 region around the centroid.");
    _centerKeys["SAT"] = schema.addField<afw::table::Flag>(
            name + "_flag_saturatedCenter", "Saturated pixel in the 3x3 region around the centroid.");
    _centerKeys["CR"] = schema.addField<afw::table::Flag>(
            name + "_flag_crCenter", "Cosmic ray in the 3x3 region around the centroid.");
    _centerKeys["BAD"] = schema.addField<afw::table::Flag>(name + "_flag_badCenter",
                                                           "Bad pixel in the 3x3 region around the centroid");
    _centerKeys["SUSPECT"] = schema.addField<afw::table::Flag>(
            name + "_flag_suspectCenter", "Suspect pixel in the 3x3 region around the centroid.");
 
    // Flags that correspond to mask bits which are set on all of the 3x3 central pixels of the object.
    _centerAllKeys["EDGE"] = schema.addField<afw::table::Flag>(
            name + "_flag_edgeCenterAll",
            "All pixels in the 3x3 region around the centroid are marked EDGE.");
    _centerAllKeys["NO_DATA"] = schema.addField<afw::table::Flag>(
            name + "_flag_nodataCenterAll",
            "All pixels in the 3x3 region around the centroid are marked NO_DATA");
    _centerAllKeys["INTRP"] = schema.addField<afw::table::Flag>(
            name + "_flag_interpolatedCenterAll",
            "All pixels in the 3x3 region around the centroid are interpolated.");
    _centerAllKeys["SAT"] = schema.addField<afw::table::Flag>(
            name + "_flag_saturatedCenterAll",
            "All pixels in the 3x3 region around the centroid are saturated.");
    _centerAllKeys["CR"] = schema.addField<afw::table::Flag>(
            name + "_flag_crCenterAll",
            "All pixels in the 3x3 region around the centroid have the cosmic ray mask bit.");
    _centerAllKeys["BAD"] = schema.addField<afw::table::Flag>(
            name + "_flag_badCenterAll", "All pixels in the 3x3 region around the centroid are bad.");
    _centerAllKeys["SUSPECT"] = schema.addField<afw::table::Flag>(
            name + "_flag_suspectCenterAll", "All pixels in the 3x3 region around the centroid are suspect.");
 
    // Read in the flags passed from the configuration, and add them to the schema
    for (auto const& i : _ctrl.masksFpCenter) {
        std::string maskName(i);
        std::transform(maskName.begin(), maskName.end(), maskName.begin(), ::tolower);
        _centerKeys[i] = schema.addField<afw::table::Flag>(
                name + "_flag_" + maskName + "Center", "3x3 region around the centroid has " + i + " pixels");
    }
    for (auto const& i : _ctrl.masksFpCenter) {
        std::string maskName(i);
        std::transform(maskName.begin(), maskName.end(), maskName.begin(), ::tolower);
        _centerAllKeys[i] = schema.addField<afw::table::Flag>(
                name + "_flag_" + maskName + "CenterAll",
                "All pixels in the 3x3 region around the source centroid are " + i + " pixels");
    }
 
    for (auto const& i : _ctrl.masksFpAnywhere) {
        std::string maskName(i);
        std::transform(maskName.begin(), maskName.end(), maskName.begin(), ::tolower);
        _anyKeys[i] = schema.addField<afw::table::Flag>(name + "_flag_" + maskName,
                                                        "Source footprint includes " + i + " pixels");
    }
}

Member Function Documentation

fail()

void lsst::meas::base::PixelFlagsAlgorithm::fail ( afw::table::SourceRecord & measRecord, MeasurementError * error = nullptr ) const

virtual

Handle an exception thrown by the current algorithm by setting flags in the given record.

fail() is called by the measurement framework when an exception is allowed to propagate out of one the algorithm's measure() methods. It should generally set both a general failure flag for the algorithm as well as a specific flag indicating the error condition, if possible. To aid in this, if the exception was an instance of MeasurementError, it will be passed in, carrying information about what flag to set.

An algorithm can also to chose to set flags within its own measure() methods, and then just return, rather than throw an exception. However, fail() should be implemented even when all known failure modes do not throw exceptions, to ensure that unexpected exceptions thrown in lower-level code are properly handled.

Implements lsst::meas::base::BaseAlgorithm.

Definition at line 262 of file PixelFlags.cc.

                                                                                              {
    measRecord.set(_generalFailureKey, true);
}

getLogName()

std::string lsst::meas::base::BaseAlgorithm::getLogName ( ) const

inlineinherited

Definition at line 66 of file Algorithm.h.

{ return _logName; }

measure()

void lsst::meas::base::PixelFlagsAlgorithm::measure ( afw::table::SourceRecord & measRecord, afw::image::Exposure< float > const & exposure ) const

virtual

Called to measure a single child source in an image.

Before this method is called, all neighbors will be replaced with noise, using the outputs of the deblender. Outputs should be saved in the given SourceRecord, which can also be used to obtain centroid (see SafeCentroidExtractor) and shape (see SafeShapeExtractor) information.

Implements lsst::meas::base::SingleFrameAlgorithm.

Definition at line 183 of file PixelFlags.cc.

                                                                                 {
    MaskedImageF mimage = exposure.getMaskedImage();
    FootprintBits<MaskedImageF> func;
 
    // Check if the measRecord has a valid centroid key, i.e. it was centroided
    geom::Point2D center;
    if (measRecord.getTable()->getCentroidSlot().getMeasKey().isValid()) {
        center = measRecord.getCentroid();
    } else {
        // Set the general failure flag because using the Peak might affect
        // the current measurement
        measRecord.set(_generalFailureKey, true);
        // Attempting to set pixel flags with no centroider, the center will
        // be determined though the peak pixel. The first peak in the
        // footprint (supplied by the measurement framework) should be the
        // highest peak so that one will be used as a proxy for the central
        // tendency of the distribution of flux for the record.
        std::shared_ptr<afw::detection::Footprint> footprint = measRecord.getFootprint();
        // If there is no footprint or the footprint contains no peaks, throw
        // a runtime error.
        if (!footprint || footprint->getPeaks().empty()) {
            throw LSST_EXCEPT(pex::exceptions::RuntimeError, "No footprint, or no footprint peaks detected");
        } else {
            center.setX(footprint->getPeaks().front().getFx());
            center.setY(footprint->getPeaks().front().getFy());
        }
    }
 
    // Flag centroids off the image.
    // Float bbox to properly handle non-finite centroids (casting Point2D->Point2I breaks NaN/inf).
    geom::Box2D bbox(mimage.getBBox());
    if (!bbox.contains(center)) {
        measRecord.set(_offImageKey, true);
        measRecord.set(_anyKeys.at("EDGE"), true);
        measRecord.set(_centerKeys.at("EDGE"), true);
        measRecord.set(_centerAllKeys.at("EDGE"), true);
    }
 
    // Check for bits set in the source's Footprint
    auto footprint = measRecord.getFootprint();
    if (!footprint) {
        throw LSST_EXCEPT(pex::exceptions::RuntimeError,
                          (boost::format("Source id %d has no footprint.") % measRecord.getId()).str());
    }
    auto fullSpans = footprint->getSpans();
    if (!fullSpans) {
        throw LSST_EXCEPT(
                pex::exceptions::RuntimeError,
                (boost::format("Source id %d has no spans in footprint.") % measRecord.getId()).str());
    }
    fullSpans->clippedTo(mimage.getBBox())->applyFunctor(func, *(mimage.getMask()));
 
    // update the source record for the any keys
    updateFlags(_anyKeys, func, measRecord);
 
    if (!(std::isfinite(center.getX()) && std::isfinite(center.getY()))) {
        auto msg =
                (boost::format("Centroid of source id %d passed to PixelFlags is non-finite; "
                               "footprint-based flags have been set, but centroid-based flags will not be.") %
                 measRecord.getId())
                        .str();
        throw LSST_EXCEPT(pex::exceptions::RuntimeError, msg);
    } else {
        // Check for bits set in the 3x3 box around the center
        geom::Point2I llc(afw::image::positionToIndex(center.getX()) - 1,
                          afw::image::positionToIndex(center.getY()) - 1);
 
        func.reset();
        auto spans = std::make_shared<afw::geom::SpanSet>(geom::Box2I(llc, geom::ExtentI(3)));
        afw::detection::Footprint const middle(spans);  // central 3x3
        middle.getSpans()->clippedTo(mimage.getBBox())->applyFunctor(func, *(mimage.getMask()));
 
        // Update the flags which have to do with the center of the footprint
        updateFlags(_centerKeys, func, measRecord);
        updateFlagsAll(_centerAllKeys, func, measRecord);
    }
}

measureForced()

void lsst::meas::base::SimpleAlgorithm::measureForced ( afw::table::SourceRecord & measRecord, afw::image::Exposure< float > const & exposure, afw::table::SourceRecord const & refRecord, afw::geom::SkyWcs const & refWcs ) const

inlineoverridevirtualinherited

Called to measure a single child source in an image.

Before this method is called, all neighbors will be replaced with noise, using the outputs of the deblender. Outputs should be saved in the given SourceRecord, which can also be used to obtain centroid (see SafeCentroidExtractor) and shape (see SafeShapeExtractor) information.

Implements lsst::meas::base::ForcedAlgorithm.

Reimplemented in lsst::meas::extensions::photometryKron::KronFluxAlgorithm.

Definition at line 172 of file Algorithm.h.

                                                                           {
        measure(measRecord, exposure);
    }

measureN()

void lsst::meas::base::SingleFrameAlgorithm::measureN ( afw::table::SourceCatalog const & measCat, afw::image::Exposure< float > const & exposure ) const

virtualinherited

Called to simultaneously measure all children in a deblend family, in a single image.

Outputs should be saved in the given SourceCatalog, which can also be used to obtain centroid (see SafeCentroidExtractor) and shape (see SafeShapeExtractor) information.

The default implementation simply throws an exception, indicating that simultaneous measurement is not supported.

Definition at line 31 of file Algorithm.cc.

                                                                                   {
    throw LSST_EXCEPT(pex::exceptions::LogicError, "measureN not implemented for this algorithm");
}

measureNForced()

void lsst::meas::base::SimpleAlgorithm::measureNForced ( afw::table::SourceCatalog const & measCat, afw::image::Exposure< float > const & exposure, afw::table::SourceCatalog const & refRecord, afw::geom::SkyWcs const & refWcs ) const

inlineoverridevirtualinherited

Called to simultaneously measure all children in a deblend family, in a single image.

Outputs should be saved in the given SourceCatalog, which can also be used to obtain centroid (see SafeCentroidExtractor) and shape (see SafeShapeExtractor) information.

The default implementation simply throws an exception, indicating that simultaneous measurement is not supported.

Reimplemented from lsst::meas::base::ForcedAlgorithm.

Definition at line 179 of file Algorithm.h.

                                                                            {
        measureN(measCat, exposure);
    }

Member Data Documentation

_logName

std::string lsst::meas::base::BaseAlgorithm::_logName

protectedinherited

Definition at line 69 of file Algorithm.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/meas_base/g56a49b3a55+369644a549/include/lsst/meas/base/PixelFlags.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/meas_base/g56a49b3a55+369644a549/src/PixelFlags.cc