lsst::meas::base::SdssShapeAlgorithm Class Reference

Measure the image moments of source using adaptive Gaussian weights. More...

#include <SdssShape.h>

Inheritance diagram for lsst::meas::base::SdssShapeAlgorithm:

Public Types
enum	{   FAILURE =FlagHandler::FAILURE, UNWEIGHTED_BAD, UNWEIGHTED, SHIFT,   MAXITER, N_FLAGS }
typedef SdssShapeControl	Control
typedef SdssShapeResult	Result
typedef SdssShapeResultKey	ResultKey

Public Member Functions
	SdssShapeAlgorithm (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
template<typename ImageT >
SdssShapeResult	computeAdaptiveMoments (ImageT const &image, afw::geom::Point2D const &center, Control const &control)
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 ()

Static Public Member Functions
template<typename ImageT >
static Result	computeAdaptiveMoments (ImageT const &image, afw::geom::Point2D const &position, Control const &ctrl=Control())
template<typename ImageT >
static FluxResult	computeFixedMomentsFlux (ImageT const &image, afw::geom::ellipses::Quadrupole const &shape, afw::geom::Point2D const &position)

Private Attributes
Control	_ctrl
ResultKey	_resultKey
SafeCentroidExtractor	_centroidExtractor

Detailed Description

Measure the image moments of source using adaptive Gaussian weights.

This algorithm measures the weighted second moments of an image using a Gaussian weight function, which is iteratively updated to match the current weights. If this iteration does not converge, it can fall back to using unweighted moments, which can be significantly noisier.

See Bernstein & Jarvis, 2002, for more information on this type of algorithm. Note that the code here makes no attempt to correct for the PSF; for PSF corrected ellipticities using weighted moments please use the shapeHSM package.

Definition at line 133 of file SdssShape.h.

Member Typedef Documentation

typedef SdssShapeControl lsst::meas::base::SdssShapeAlgorithm::Control

Definition at line 136 of file SdssShape.h.

typedef SdssShapeResult lsst::meas::base::SdssShapeAlgorithm::Result

Definition at line 137 of file SdssShape.h.

typedef SdssShapeResultKey lsst::meas::base::SdssShapeAlgorithm::ResultKey

Definition at line 138 of file SdssShape.h.

Member Enumeration Documentation

anonymous enum

Enumerator
FAILURE
UNWEIGHTED_BAD
UNWEIGHTED
SHIFT
MAXITER
N_FLAGS

Definition at line 140 of file SdssShape.h.

         {
        FAILURE=FlagHandler::FAILURE,
        UNWEIGHTED_BAD,
        UNWEIGHTED,
        SHIFT,
        MAXITER,
        N_FLAGS
    };

Constructor & Destructor Documentation

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

Definition at line 742 of file SdssShape.cc.

  : _ctrl(ctrl),
    _resultKey(ResultKey::addFields(schema, name)),
    _centroidExtractor(schema, name)
{}

Member Function Documentation

template<typename ImageT >

static Result lsst::meas::base::SdssShapeAlgorithm::computeAdaptiveMoments ( ImageT const &  image, afw::geom::Point2D const &  position, Control const &  ctrl = Control()  )

static

Compute the adaptive Gaussian-weighted moments of an image.

Parameters

[in]	image	An Image or MaskedImage instance with int, float, or double pixels. This need not be a small postage stamp (the pixel region actually used in the fit will be a subset of this image determined automatically).
[in]	position	Center position of the object to be measured, in the image's PARENT coordinates.
[in]	ctrl	Control object specifying the details of how the object is to be measured.

template<typename ImageT >

SdssShapeResult lsst::meas::base::SdssShapeAlgorithm::computeAdaptiveMoments	(	ImageT const &	image,
		afw::geom::Point2D const &	center,
		Control const &	control
	)

Definition at line 753 of file SdssShape.cc.

  {
    double xcen = center.getX();         // object's column position
    double ycen = center.getY();         // object's row position

    xcen -= image.getX0();             // work in image Pixel coordinates
    ycen -= image.getY0();

    float shiftmax = control.maxShift;   // Max allowed centroid shift
    if (shiftmax < 2) {
        shiftmax = 2;
    } else if (shiftmax > 10) {
        shiftmax = 10;
    }

    SdssShapeResult result;
    try {
        result.flags[FAILURE] = !getAdaptiveMoments(
            image, control.background, xcen, ycen, shiftmax, &result,
            control.maxIter, control.tol1, control.tol2
        );
    } catch (pex::exceptions::Exception & err) {
        result.flags[FAILURE] = true;
    }
    if (result.flags[UNWEIGHTED] || result.flags[SHIFT]) {
        // These are also considered fatal errors in terms of the quality of the results,
        // even though they do produce some results.
        result.flags[FAILURE] = true;
    }
    if (result.getQuadrupole().getDeterminant() < 0) {
        if (!result.flags[FAILURE]) {
            throw LSST_EXCEPT(
                pex::exceptions::LogicError,
                "Should not get singular moments unless a flag is set");
        }
    }

    // getAdaptiveMoments() just computes the zeroth moment in result.flux (and its error in
    // result.fluxSigma, result.flux_xx_Cov, etc.)  That's related to the flux by some geometric
    // factors, which we apply here.
    double fluxScale = computeFluxScale(result);

    result.flux *= fluxScale;
    result.fluxSigma *= fluxScale;
    result.x += image.getX0();
    result.y += image.getY0();

    if (ImageAdaptor<ImageT>::hasVariance) {
        result.flux_xx_Cov *= fluxScale;
        result.flux_yy_Cov *= fluxScale;
        result.flux_xy_Cov *= fluxScale;
    }

    return result;
}

template<typename ImageT >

template FluxResult lsst::meas::base::SdssShapeAlgorithm::computeFixedMomentsFlux ( ImageT const &  image, afw::geom::ellipses::Quadrupole const &  shape, afw::geom::Point2D const &  position  )

static

Compute the flux within a fixed Gaussian aperture.

Parameters

[in]	image	An Image or MaskedImage instance with int, float, or double pixels. This need not be a small postage stamp (the pixel region actually used in the fit will be a subset of this image determined automatically).
[in]	shape	Ellipse object specifying the 1-sigma contour of the Gaussian.
[in]	position	Center position of the object to be measured, in the image's PARENT coordinates.

Definition at line 813 of file SdssShape.cc.

  {
    // while arguments to computeFixedMomentsFlux are in PARENT coordinates, the implementation is LOCAL.
    afw::geom::Point2D localCenter = center - afw::geom::Extent2D(image.getXY0());

    afwGeom::BoxI const bbox = computeAdaptiveMomentsBBox(image.getBBox(afw::image::LOCAL),
                                                          localCenter,
                                                          shape.getIxx(), shape.getIxy(), shape.getIyy());

    boost::tuple<std::pair<bool, double>, double, double, double> weights =
        getWeights(shape.getIxx(), shape.getIxy(), shape.getIyy());

    FluxResult result;

    if (!weights.get<0>().first) {
        throw pex::exceptions::InvalidParameterError("Input shape is singular");
    }

    double const w11 = weights.get<1>();
    double const w12 = weights.get<2>();
    double const w22 = weights.get<3>();
    bool const interp = shouldInterp(shape.getIxx(), shape.getIyy(), weights.get<0>().second);

    double i0 = 0;                      // amplitude of Gaussian
    if (calcmom<true>(ImageAdaptor<ImageT>().getImage(image), localCenter.getX(), localCenter.getY(),
                      bbox, 0.0, interp, w11, w12, w22, &i0, NULL, NULL, NULL, NULL, NULL, NULL, NULL)< 0) {
        throw LSST_EXCEPT(pex::exceptions::RuntimeError, "Error from calcmom");
    }

    double const wArea = afw::geom::PI*std::sqrt(shape.getDeterminant());

    result.flux = i0*2*wArea;

    if (ImageAdaptor<ImageT>::hasVariance) {
        int ix = static_cast<int>(center.getX() - image.getX0());
        int iy = static_cast<int>(center.getY() - image.getY0());
        if (!image.getBBox(afw::image::LOCAL).contains(afw::geom::Point2I(ix, iy))) {
            throw LSST_EXCEPT(pex::exceptions::RuntimeError,
                              (boost::format("Center (%d,%d) not in image (%dx%d)") %
                               ix % iy % image.getWidth() % image.getHeight()).str());
        }
        double var = ImageAdaptor<ImageT>().getVariance(image, ix, iy);
        double i0Err = std::sqrt(var/wArea);
        result.fluxSigma = i0Err*2*wArea;
    }

    return result;
}

void lsst::meas::base::SdssShapeAlgorithm::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 877 of file SdssShape.cc.

        {
    _resultKey.getFlagHandler().handleFailure(measRecord, error);
}

void lsst::meas::base::SdssShapeAlgorithm::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 865 of file SdssShape.cc.

        {
    SdssShapeResult result = computeAdaptiveMoments(
        exposure.getMaskedImage(),
        _centroidExtractor(measRecord, _resultKey.getFlagHandler()),
        _ctrl
    );
    measRecord.set(_resultKey, result);
}

Member Data Documentation

SafeCentroidExtractor lsst::meas::base::SdssShapeAlgorithm::_centroidExtractor

private

Definition at line 196 of file SdssShape.h.

Control lsst::meas::base::SdssShapeAlgorithm::_ctrl

private

Definition at line 194 of file SdssShape.h.

ResultKey lsst::meas::base::SdssShapeAlgorithm::_resultKey

private

Definition at line 195 of file SdssShape.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/SdssShape.h
• /home/lsstsw/stack/Linux64/meas_base/11.0+1/src/SdssShape.cc