#include <ApertureFlux.h>

Inheritance diagram for lsst::meas::base::ApertureFluxAlgorithm:

Classes
struct	Keys

Public Types
enum	FlagBits { FAILURE =0, APERTURE_TRUNCATED, SINC_COEFFS_TRUNCATED, N_FLAGS }

typedef ApertureFluxControl	Control
	Typedef to the control object associated with this algorithm, defined above. More...

typedef ApertureFluxResult	Result
	Result object returned by static methods. More...

Public Member Functions
	ApertureFluxAlgorithm (Control const &ctrl, std::string const &name, afw::table::Schema &schema, daf::base::PropertySet &metadata)

virtual	~ApertureFluxAlgorithm ()

virtual void	measure (afw::table::SourceRecord &record, afw::image::Exposure< float > const &exposure) const =0

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 ()

Static Public Member Functions
static std::string	makeFieldPrefix (std::string const &name, double radius)


template<typename T >
static Result	computeSincFlux (afw::image::Image< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())

template<typename T >
static Result	computeSincFlux (afw::image::MaskedImage< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())


template<typename T >
static Result	computeNaiveFlux (afw::image::Image< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())

template<typename T >
static Result	computeNaiveFlux (afw::image::MaskedImage< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())


template<typename T >
static Result	computeFlux (afw::image::Image< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())

template<typename T >
static Result	computeFlux (afw::image::MaskedImage< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())

Protected Member Functions
void	copyResultToRecord (Result const &result, afw::table::SourceRecord &record, int index) const

FlagHandler const &	getFlagHandler (int index) const

Protected Attributes
Control const	_ctrl

SafeCentroidExtractor	_centroidExtractor

Private Attributes
std::vector< Keys >	_keys

Detailed Description

Base class for multiple-aperture photometry algorithms

ApertureFluxAlgorithm serves as an intermediate base class for all aperture fluxes, which it assumes have that capability of measuring multiple apertures (even if they are not always configured to do so).

Concrete implementations for single-aperture flux measurements are provided as static methods, as well as a consistent interface and control object for its derived classes. Currently, we only have one derived class, CircularApertureFluxAlgorithm, but in the future we anticipate adding more derived classes for e.g. elliptical apertures, or apertures that are circular in sky coordinates rather than pixel coordinates.

Definition at line 82 of file ApertureFlux.h.

Member Typedef Documentation

typedef ApertureFluxControl lsst::meas::base::ApertureFluxAlgorithm::Control

Typedef to the control object associated with this algorithm, defined above.

Definition at line 94 of file ApertureFlux.h.

typedef ApertureFluxResult lsst::meas::base::ApertureFluxAlgorithm::Result

Result object returned by static methods.

Definition at line 97 of file ApertureFlux.h.

Member Enumeration Documentation

enum lsst::meas::base::ApertureFluxAlgorithm::FlagBits

Enumerator
FAILURE
APERTURE_TRUNCATED
SINC_COEFFS_TRUNCATED
N_FLAGS

Definition at line 86 of file ApertureFlux.h.

                   {
         FAILURE=0,
         APERTURE_TRUNCATED,
         SINC_COEFFS_TRUNCATED,
         N_FLAGS
     };

Constructor & Destructor Documentation

lsst::meas::base::ApertureFluxAlgorithm::ApertureFluxAlgorithm	(	Control const &	ctrl,
		std::string const &	name,
		afw::table::Schema &	schema,
		daf::base::PropertySet &	metadata
	)

explicit

Construct the algorithm and add its fields to the given Schema.

Definition at line 80 of file ApertureFlux.cc.

   : _ctrl(ctrl),
     _centroidExtractor(schema, name)
 {
     _keys.reserve(ctrl.radii.size());
     for (std::size_t i = 0; i < ctrl.radii.size(); ++i) {
         metadata.add(name + "_radii", ctrl.radii[i]);
         std::string prefix = ApertureFluxAlgorithm::makeFieldPrefix(name, ctrl.radii[i]);
         std::string doc = (boost::format("flux within %f-pixel aperture") % ctrl.radii[i]).str();
         _keys.push_back(Keys(schema, prefix, doc, ctrl.radii[i] <= ctrl.maxSincRadius));
     }
 }

virtual lsst::meas::base::ApertureFluxAlgorithm::~ApertureFluxAlgorithm ( )

inlinevirtual

Definition at line 186 of file ApertureFlux.h.

186 {}

Member Function Documentation

template<typename T >

ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeFlux	(	afw::image::Image< T > const &	image,
		afw::geom::ellipses::Ellipse const &	ellipse,
		Control const &	ctrl = `Control()`
	)

static

Compute the flux (and optionally, uncertanties) within an aperture using the algorithm determined by its size and the maxSincRadius control parameter.

This method delegates to computeSincFlux is the minor axis of the aperture is smaller than ctrl.maxSincRadius, and delegates to computeNaiveFlux otherwise.

Parameters

[in]	image	Image or MaskedImage to be measured. If a MaskedImage is provided, uncertainties will be returned as well as fluxes.
[in]	ellipse	Ellipse that defines the outer boundary of the aperture.
[in]	ctrl	Control object.

Definition at line 262 of file ApertureFlux.cc.

   {
     return (afw::geom::ellipses::Axes(ellipse.getCore()).getB() <= ctrl.maxSincRadius)
         ? computeSincFlux(image, ellipse, ctrl)
         : computeNaiveFlux(image, ellipse, ctrl);
 }

template<typename T >

ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeFlux	(	afw::image::MaskedImage< T > const &	image,
		afw::geom::ellipses::Ellipse const &	ellipse,
		Control const &	ctrl = `Control()`
	)

static

Compute the flux (and optionally, uncertanties) within an aperture using the algorithm determined by its size and the maxSincRadius control parameter.

This method delegates to computeSincFlux is the minor axis of the aperture is smaller than ctrl.maxSincRadius, and delegates to computeNaiveFlux otherwise.

Parameters

[in]	image	Image or MaskedImage to be measured. If a MaskedImage is provided, uncertainties will be returned as well as fluxes.
[in]	ellipse	Ellipse that defines the outer boundary of the aperture.
[in]	ctrl	Control object.

Definition at line 273 of file ApertureFlux.cc.

   {
     return (afw::geom::ellipses::Axes(ellipse.getCore()).getB() <= ctrl.maxSincRadius)
         ? computeSincFlux(image, ellipse, ctrl)
         : computeNaiveFlux(image, ellipse, ctrl);
 }

template<typename T >

ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeNaiveFlux	(	afw::image::Image< T > const &	image,
		afw::geom::ellipses::Ellipse const &	ellipse,
		Control const &	ctrl = `Control()`
	)

static

Compute the flux (and optionally, uncertanties) within an aperture using naive photometry

The naive algorithm just counts the flux in pixels whose centers lie within the aperture, ignoring the effects of sub-pixel aperture boundaries.

Parameters

[in]	image	Image or MaskedImage to be measured. If a MaskedImage is provided, uncertainties will be returned as well as fluxes.
[in]	ellipse	Ellipse that defines the outer boundary of the aperture.

Definition at line 198 of file ApertureFlux.cc.

   {
     Result result;
     afw::geom::ellipses::PixelRegion region(ellipse); // behaves mostly like a Footprint
     if (!image.getBBox().contains(region.getBBox())) {
         result.setFlag(APERTURE_TRUNCATED);
         result.setFlag(FAILURE);
         return result;
     }
     result.flux = 0;
     for (
         afw::geom::ellipses::PixelRegion::Iterator spanIter = region.begin(), spanEnd = region.end();
         spanIter != spanEnd;
         ++spanIter
     ) {
         typename afw::image::Image<T>::x_iterator pixIter = image.x_at(
             spanIter->getBeginX() - image.getX0(),
             spanIter->getY() - image.getY0()
         );
         result.flux += std::accumulate(pixIter, pixIter + spanIter->getWidth(), 0.0);
     }
     return result;
 }

template<typename T >

ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeNaiveFlux	(	afw::image::MaskedImage< T > const &	image,
		afw::geom::ellipses::Ellipse const &	ellipse,
		Control const &	ctrl = `Control()`
	)

static

Compute the flux (and optionally, uncertanties) within an aperture using naive photometry

The naive algorithm just counts the flux in pixels whose centers lie within the aperture, ignoring the effects of sub-pixel aperture boundaries.

Parameters

[in]	image	Image or MaskedImage to be measured. If a MaskedImage is provided, uncertainties will be returned as well as fluxes.
[in]	ellipse	Ellipse that defines the outer boundary of the aperture.

Definition at line 226 of file ApertureFlux.cc.

   {
     Result result;
     afw::geom::ellipses::PixelRegion region(ellipse); // behaves mostly like a Footprint
     if (!image.getBBox().contains(region.getBBox())) {
         result.setFlag(APERTURE_TRUNCATED);
         result.setFlag(FAILURE);
         return result;
     }
     result.flux = 0.0;
     result.fluxSigma = 0.0;
     for (
         afw::geom::ellipses::PixelRegion::Iterator spanIter = region.begin(), spanEnd = region.end();
         spanIter != spanEnd;
         ++spanIter
     ) {
         typename afw::image::MaskedImage<T>::Image::x_iterator pixIter = image.getImage()->x_at(
             spanIter->getBeginX() - image.getX0(),
             spanIter->getY() - image.getY0()
         );
         typename afw::image::MaskedImage<T>::Variance::x_iterator varIter = image.getVariance()->x_at(
             spanIter->getBeginX() - image.getX0(),
             spanIter->getY() - image.getY0()
         );
         result.flux += std::accumulate(pixIter, pixIter + spanIter->getWidth(), 0.0);
         // we use this to hold variance as we accumulate...
         result.fluxSigma += std::accumulate(varIter, varIter + spanIter->getWidth(), 0.0);
     }
     result.fluxSigma = std::sqrt(result.fluxSigma); // ...and switch back to sigma here.
     return result;
 }

template<typename T >

ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeSincFlux	(	afw::image::Image< T > const &	image,
		afw::geom::ellipses::Ellipse const &	ellipse,
		Control const &	ctrl = `Control()`
	)

static

Compute the flux (and optionally, uncertanties) within an aperture using Sinc photometry

The Sinc algorithm is slower than a naive aperture, but more accurate, in that it correctly handles sub-pixel aperture boundaries on well-sampled data. This improved accuracy is most important for smaller apertures.

Parameters

[in]	image	Image or MaskedImage to be measured. If a MaskedImage is provided, uncertainties will be returned as well as fluxes.
[in]	ellipse	Ellipse that defines the outer boundary of the aperture.
[in]	ctrl	Control object.

Definition at line 164 of file ApertureFlux.cc.

   {
     Result result;
     CONST_PTR(afw::image::Image<T>) cImage = getSincCoeffs<T>(image.getBBox(), ellipse, result, ctrl);
     if (result.getFlag(APERTURE_TRUNCATED)) return result;
     afw::image::Image<T> subImage(image, cImage->getBBox());
     result.flux = (subImage.getArray().template asEigen<Eigen::ArrayXpr>()
                    * cImage->getArray().template asEigen<Eigen::ArrayXpr>()).sum();
     return result;
 }

template<typename T >

ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeSincFlux	(	afw::image::MaskedImage< T > const &	image,
		afw::geom::ellipses::Ellipse const &	ellipse,
		Control const &	ctrl = `Control()`
	)

static

Compute the flux (and optionally, uncertanties) within an aperture using Sinc photometry

The Sinc algorithm is slower than a naive aperture, but more accurate, in that it correctly handles sub-pixel aperture boundaries on well-sampled data. This improved accuracy is most important for smaller apertures.

Parameters

[in]	image	Image or MaskedImage to be measured. If a MaskedImage is provided, uncertainties will be returned as well as fluxes.
[in]	ellipse	Ellipse that defines the outer boundary of the aperture.
[in]	ctrl	Control object.

Definition at line 179 of file ApertureFlux.cc.

   {
     Result result;
     CONST_PTR(afw::image::Image<T>) cImage = getSincCoeffs<T>(image.getBBox(), ellipse, result, ctrl);
     if (result.getFlag(APERTURE_TRUNCATED)) return result;
     afw::image::MaskedImage<T> subImage(image, cImage->getBBox(afw::image::PARENT), afw::image::PARENT);
     result.flux = (subImage.getImage()->getArray().template asEigen<Eigen::ArrayXpr>()
                    * cImage->getArray().template asEigen<Eigen::ArrayXpr>()).sum();
     result.fluxSigma = std::sqrt(
         (subImage.getVariance()->getArray().template asEigen<Eigen::ArrayXpr>().template cast<T>()
          * cImage->getArray().template asEigen<Eigen::ArrayXpr>().square()).sum()
     );
     return result;
 }

void lsst::meas::base::ApertureFluxAlgorithm::copyResultToRecord	(	Result const &	result,
		afw::table::SourceRecord &	record,
		int	index
	)		const

protected

Definition at line 107 of file ApertureFlux.cc.

         {
     record.set(_keys[index].fluxKey, result);
     if (result.getFlag(FAILURE)) {
         _keys[index].flags.setValue(record, FAILURE, true);
     }
     if (result.getFlag(APERTURE_TRUNCATED)) {
         _keys[index].flags.setValue(record, APERTURE_TRUNCATED, true);
     }
     if (result.getFlag(SINC_COEFFS_TRUNCATED)) {
         _keys[index].flags.setValue(record, SINC_COEFFS_TRUNCATED, true);
     }
 }

void lsst::meas::base::ApertureFluxAlgorithm::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 98 of file ApertureFlux.cc.

                                                                                                   {
     // This should only get called in the case of completely unexpected failures, so it's not terrible
     // that we just set the general failure flags for all radii here instead of trying to figure out
     // which ones we've already done.  Any known failure modes are handled inside measure().
     for (std::size_t i = 0; i < _ctrl.radii.size(); ++i) {
         _keys[i].flags.handleFailure(measRecord, error);
     }
 }

FlagHandler const& lsst::meas::base::ApertureFluxAlgorithm::getFlagHandler ( int index ) const

inlineprotected

Definition at line 225 of file ApertureFlux.h.

225 { return _keys[index].flags; }

lsst::meas::base::ApertureFluxAlgorithm::_keys

std::vector< Keys > _keys

Definition: ApertureFlux.h:239

std::string lsst::meas::base::ApertureFluxAlgorithm::makeFieldPrefix	(	std::string const &	name,
		double	radius
	)

static

Construct an appropriate prefix for table fields.

Given a plugin name (e.g. base_CircularApertureFlux) and an aperture radius (e.g. 12 pixels) return an appropriate prefix for table fields to contain the measurement results (e.g. base_CircularApertureFlux_12_0). Table fields can then be created named <prefix>_flux, <prefix>_fluxErr, etc.

Parameters

[in]	pluginName	Name of measurement plugin.
[in]	radius	Aperture radius (pixels).

Returns: Table field name prefix.

Definition at line 62 of file ApertureFlux.cc.

                                                                                       {
     std::string prefix = (boost::format("%s_%.1f") % name % radius).str();
     return boost::replace_all_copy(prefix, ".", "_");
 }

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

pure virtual

Measure the configured apertures on the given image.

Python plugins will delegate to this method.

Parameters

[in,out]	record	Record used to save outputs and retrieve positions.
[in]	exposure	Image to be measured.

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

Implemented in lsst::meas::base::CircularApertureFluxAlgorithm.

Member Data Documentation

SafeCentroidExtractor lsst::meas::base::ApertureFluxAlgorithm::_centroidExtractor

protected

Definition at line 228 of file ApertureFlux.h.

Control const lsst::meas::base::ApertureFluxAlgorithm::_ctrl

protected

Definition at line 227 of file ApertureFlux.h.

std::vector<Keys> lsst::meas::base::ApertureFluxAlgorithm::_keys

private

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation