lsst::meas::base::SdssCentroidAlgorithm Class Reference

The Sdss Centroid Algorithm. More...

#include <SdssCentroid.h>

Inheritance diagram for lsst::meas::base::SdssCentroidAlgorithm:

Public Types
enum	{   FAILURE =FlagHandler::FAILURE, EDGE, NO_SECOND_DERIVATIVE, ALMOST_NO_SECOND_DERIVATIVE,   NOT_AT_MAXIMUM, N_FLAGS }
typedef SdssCentroidControl	Control

Public Member Functions
	SdssCentroidAlgorithm (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
virtual void	fail (afw::table::SourceRecord &measRecord, MeasurementError *error=NULL) const
Public Member Functions inherited from lsst::meas::base::SimpleAlgorithm
virtual void	measureForced (afw::table::SourceRecord &measRecord, afw::image::Exposure< float > const &exposure, afw::table::SourceRecord const &refRecord, afw::image::Wcs const &refWcs) const
virtual void	measureNForced (afw::table::SourceCatalog const &measCat, afw::image::Exposure< float > const &exposure, afw::table::SourceCatalog const &refRecord, afw::image::Wcs const &refWcs) const
Public Member Functions inherited from lsst::meas::base::SingleFrameAlgorithm
virtual void	measureN (afw::table::SourceCatalog const &measCat, afw::image::Exposure< float > const &exposure) const
Public Member Functions inherited from lsst::meas::base::BaseAlgorithm
virtual	~BaseAlgorithm ()

Private Attributes
Control	_ctrl
CentroidResultKey	_centroidKey
FlagHandler	_flagHandler
SafeCentroidExtractor	_centroidExtractor

Detailed Description

The Sdss Centroid Algorithm.

Definition at line 65 of file SdssCentroid.h.

Member Typedef Documentation

typedef SdssCentroidControl lsst::meas::base::SdssCentroidAlgorithm::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 79 of file SdssCentroid.h.

Member Enumeration Documentation

anonymous enum

Enumerator
FAILURE
EDGE
NO_SECOND_DERIVATIVE
ALMOST_NO_SECOND_DERIVATIVE
NOT_AT_MAXIMUM
N_FLAGS

Definition at line 68 of file SdssCentroid.h.

         {
        FAILURE=FlagHandler::FAILURE,
        EDGE,
        NO_SECOND_DERIVATIVE,
        ALMOST_NO_SECOND_DERIVATIVE,
        NOT_AT_MAXIMUM,
        N_FLAGS
    };

Constructor & Destructor Documentation

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

Definition at line 423 of file SdssCentroid.cc.

  : _ctrl(ctrl),
    _centroidKey( 
        CentroidResultKey::addFields(schema, name, "centroid from Sdss Centroid algorithm", SIGMA_ONLY)
    ),
    _centroidExtractor(schema, name, true)
{   
    _flagHandler = FlagHandler::addFields(schema, name,
                                          getFlagDefinitions().begin(), getFlagDefinitions().end());
}

Member Function Documentation

void lsst::meas::base::SdssCentroidAlgorithm::fail ( afw::table::SourceRecord &  measRecord, MeasurementError *  error = NULL  ) 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 536 of file SdssCentroid.cc.

                                                                                                  {
    _flagHandler.handleFailure(measRecord, error);
}

void lsst::meas::base::SdssCentroidAlgorithm::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 436 of file SdssCentroid.cc.

        {

    // get our current best guess about the centroid: either a centroider measurement or peak.
    afw::geom::Point2D center = _centroidExtractor(measRecord, _flagHandler);
    CentroidResult result;
    result.x = center.getX();
    result.y = center.getY();
    measRecord.set(_centroidKey, result); // better than NaN

    typedef afw::image::Exposure<float>::MaskedImageT MaskedImageT;
    typedef MaskedImageT::Image ImageT;
    typedef MaskedImageT::Variance VarianceT;

    MaskedImageT const& mimage = exposure.getMaskedImage();
    ImageT const& image = *mimage.getImage();
    CONST_PTR(lsst::afw::detection::Psf) psf = exposure.getPsf();

    int const x = image.positionToIndex(center.getX(), lsst::afw::image::X).first;
    int const y = image.positionToIndex(center.getY(), lsst::afw::image::Y).first;

    if (!image.getBBox().contains(lsst::afw::geom::Extent2I(x,y) + image.getXY0())) {
            throw LSST_EXCEPT(
            lsst::meas::base::MeasurementError,
            _flagHandler.getDefinition(EDGE).doc,
            EDGE
        );
    }

    // Algorithm uses a least-squares fit (implemented via a convolution) to a symmetrized PSF model.
    // If you don't have a Psf, you need to use another centroider, such as GaussianCentroider.
    if (!psf) {
        throw LSST_EXCEPT(
            FatalAlgorithmError,
            "SdssCentroid algorithm requires a Psf with every exposure"
        );
    }

    int binX = 1;
    int binY = 1;
    double xc=0., yc=0., dxc=0., dyc=0.;            // estimated centre and error therein
    for(int binsize = 1; binsize <= _ctrl.binmax; binsize *= 2) {
        std::pair<MaskedImageT, double> result = smoothAndBinImage(psf, x, y, mimage, binX, binY, _flagHandler);
        MaskedImageT const smoothedImage = result.first;
        double const smoothingSigma = result.second;

        MaskedImageT::xy_locator mim = smoothedImage.xy_at(smoothedImage.getWidth()/2,
                                                                    smoothedImage.getHeight()/2);

        double sizeX2, sizeY2;      // object widths^2 in x and y directions
        double peakVal;             // peak intensity in image

        doMeasureCentroidImpl(&xc, &dxc, &yc, &dyc, &sizeX2, &sizeY2, &peakVal, mim,
            smoothingSigma, _flagHandler);

        if(binsize > 1) {
            // dilate from the lower left corner of central pixel
            xc = (xc + 0.5)*binX - 0.5;
            dxc *= binX;
            sizeX2 *= binX*binX;

            yc = (yc + 0.5)*binY - 0.5;
            dyc *= binY;
            sizeY2 *= binY*binY;
        }

        xc += x;                    // xc, yc are measured relative to pixel (x, y)
        yc += y;

        double const fac = _ctrl.wfac*(1 + smoothingSigma*smoothingSigma);
        double const facX2 = fac*binX*binX;
        double const facY2 = fac*binY*binY;

        if (sizeX2 < facX2 && ::pow(xc - x, 2) < facX2 &&
            sizeY2 < facY2 && ::pow(yc - y, 2) < facY2) {
            if (binsize > 1 || _ctrl.peakMin < 0.0 || peakVal > _ctrl.peakMin) {
                break;
            }
        }

        if (sizeX2 >= facX2 || ::pow(xc - x, 2) >= facX2) {
            binX *= 2;
        }
        if (sizeY2 >= facY2 || ::pow(yc - y, 2) >= facY2) {
            binY *= 2;
        }
    }
    result.x = lsst::afw::image::indexToPosition(xc + image.getX0());
    result.y = lsst::afw::image::indexToPosition(yc + image.getY0());

    result.xSigma = sqrt(dxc*dxc);
    result.ySigma = sqrt(dyc*dyc);
    measRecord.set(_centroidKey, result);
    _flagHandler.setValue(measRecord, FAILURE, false);

}

Member Data Documentation

SafeCentroidExtractor lsst::meas::base::SdssCentroidAlgorithm::_centroidExtractor

private

Definition at line 98 of file SdssCentroid.h.

CentroidResultKey lsst::meas::base::SdssCentroidAlgorithm::_centroidKey

private

Definition at line 96 of file SdssCentroid.h.

Control lsst::meas::base::SdssCentroidAlgorithm::_ctrl

private

Definition at line 95 of file SdssCentroid.h.

FlagHandler lsst::meas::base::SdssCentroidAlgorithm::_flagHandler

private

Definition at line 97 of file SdssCentroid.h.

---

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

• /home/lsstsw/stack/Linux64/meas_base/11.0+1/include/lsst/meas/base/SdssCentroid.h
• /home/lsstsw/stack/Linux64/meas_base/11.0+1/src/SdssCentroid.cc