lsst::meas::base::CentroidChecker Class Reference

#include <CentroidUtilities.h>

Public Member Functions
	CentroidChecker (afw::table::Schema &schema, std::string const &name, bool inside=true, double maxDistFromPeak=-1.0)
	Check source record produced by a centroid algorithm called "name". More...
bool	operator() (afw::table::SourceRecord &record) const
	Set the centroid to the first footprint if the centroid is either more than _dist pixels from the footprint center, or if it is outside the footprint. More...

Detailed Description

Definition at line 190 of file CentroidUtilities.h.

Constructor & Destructor Documentation

CentroidChecker()

lsst::meas::base::CentroidChecker::CentroidChecker	(	afw::table::Schema &	schema,
		std::string const &	name,
		bool	inside = true,
		double	maxDistFromPeak = -1.0
	)

Check source record produced by a centroid algorithm called "name".

If the centroid is accompanied by uncertainties (the xErr and yErr fields), these should not be NaN. If they are, the algorithmName + "_flag_badError" flag and the general failure flag for the algorithm are both set.

If the centroid set by the algorithm lies outside the footprint attached to the record, or the centroid is more than "dist" pixels from the footprint peak:

(1) the general failure flag for the algorithm is set (2) algorithmName + "_flag_resetToPeak" flag is set (3) the position of the centroid is changed to that of the footprint Peak

Parameters

[in,out]	schema	Schema to which the flag_resetToPeak is to be added
[in]	name	The name of the algorithm we will be checking
[in]	doFootprintCheck	Check if centroid is within footprint
[in]	maxDistFromPeak	Check if centroid is more than dist from footprint peak

Definition at line 174 of file CentroidUtilities.cc.

        : _doFootprintCheck(doFootprintCheck), _maxDistFromPeak(maxDistFromPeak) {
    _resetKey = schema.addField<afw::table::Flag>(schema.join(name, "flag_resetToPeak"),
                                                  "set if CentroidChecker reset the centroid");
    _failureKey = schema.find<afw::table::Flag>(schema.join(name, "flag")).key;
    _xKey = schema.find<CentroidElement>(schema.join(name, "x")).key;
    _yKey = schema.find<CentroidElement>(schema.join(name, "y")).key;
 
    // We only check errors on the centroid if they exist: not all measurement
    // algorithms provide them.
    try {
        _xErrKey = schema.find<ErrElement>(schema.join(name, "xErr")).key;
    } catch (pex::exceptions::NotFoundError &err) {}
    try {
        _yErrKey = schema.find<ErrElement>(schema.join(name, "yErr")).key;
    } catch (pex::exceptions::NotFoundError &err) {}
    if (_xErrKey.isValid() || _yErrKey.isValid()) {
        _badErrorKey = schema.addField<afw::table::Flag>(schema.join(name, "flag_badError"),
                                                         "Error on x and/or y position is NaN");
    }
}

Member Function Documentation

operator()()

bool lsst::meas::base::CentroidChecker::operator()

(

afw::table::SourceRecord &

record

)

const

Set the centroid to the first footprint if the centroid is either more than _dist pixels from the footprint center, or if it is outside the footprint.

Set appropriate flags to indicate any changes to the centroid, and to indicate if uncertainties are set to invalid ("NaN") values.

Definition at line 197 of file CentroidUtilities.cc.

                                                                   {
    CentroidElement x = record.get(_xKey);
    CentroidElement y = record.get(_yKey);
 
    // Check any errors specified on the centroid position are valid.
    if ((_xErrKey.isValid() && std::isnan(record.get(_xErrKey))) ||
        (_yErrKey.isValid() && std::isnan(record.get(_yErrKey)))) {
        record.set(_badErrorKey, true);
        record.set(_failureKey, true);
    }
 
    // Only proceed with checking if appropriately configured.
    if (!_doFootprintCheck && _maxDistFromPeak < 0.0) {
        return false;
    }
 
    // Check that the centroid has a footprint that we can validate; otherwise, give up.
    std::shared_ptr<afw::detection::Footprint> footprint = record.getFootprint();
    if (!footprint) {
        throw LSST_EXCEPT(pex::exceptions::RuntimeError, "No Footprint attached to record");
    }
    if (footprint->getPeaks().empty()) {
        throw LSST_EXCEPT(pex::exceptions::RuntimeError, "Footprint has no peaks; cannot verify centroid.");
    }
 
    // Set the centroid to the first footprint if the centroid is either more than
    // _maxDistFromPeak pixels from the centroid, or if it is outside the footprint.
    CentroidElement footX = footprint->getPeaks().front().getFx();
    CentroidElement footY = footprint->getPeaks().front().getFy();
    double distsq = (x - footX) * (x - footX) + (y - footY) * (y - footY);
    if ((_doFootprintCheck && !footprint->contains(geom::Point2I(geom::Point2D(x, y)))) ||
        ((_maxDistFromPeak > 0) && (distsq > _maxDistFromPeak * _maxDistFromPeak))) {
        record.set(_xKey, footX);
        record.set(_yKey, footY);
        record.set(_failureKey, true);
        record.set(_resetKey, true);
        return true;
    }
    return false;
}

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_base/22.0.1-25-gb120d7b+8b5510f75f/include/lsst/meas/base/CentroidUtilities.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_base/22.0.1-25-gb120d7b+8b5510f75f/src/CentroidUtilities.cc