Classes
class	BaseAlgorithm
	Ultimate abstract base class for all C++ measurement algorithms. More...

class	SingleFrameAlgorithm
	Base class for algorithms that measure the properties of sources on single image. More...

class	ForcedAlgorithm
	Base class for algorithms that measure the properties of sources on one image, using previous measurements on another image to hold certain quantities fixed. More...

class	SimpleAlgorithm
	An abstract base classes for which the same implementation can be used for both SingleFrameAlgorithm and ForcedAlgorithm. More...

class	ApertureFluxControl
	Configuration object for multiple-aperture flux algorithms. More...

class	ApertureFluxAlgorithm
	Base class for multiple-aperture photometry algorithms. More...

struct	ApertureFluxResult
	A Result struct for running an aperture flux algorithm with a single radius. More...

class	ApertureFluxTransform
	Measurement transformation for aperture fluxes. More...

class	BlendednessControl

class	BlendednessAlgorithm
	Compute metrics that measure how blended objects are. More...

struct	CentroidResult
	A reusable struct for centroid measurements. More...

class	CentroidResultKey
	A FunctorKey for CentroidResult. More...

class	CentroidTransform
	Base for centroid measurement transformations. More...

class	CentroidChecker

class	CircularApertureFluxAlgorithm

class	MeasurementError
	Exception to be thrown when a measurement algorithm experiences a known failure mode. More...

struct	FlagDefinition
	Simple POD struct used to define and document flags. More...

class	FlagHandler
	Utility class for handling flag fields that indicate the failure modes of an algorithm. More...

struct	FluxResult
	A reusable result struct for flux measurements. More...

class	FluxResultKey
	A FunctorKey for FluxResult. More...

struct	MagResult
	A reusable result struct for magnitudes. More...

class	MagResultKey
	A FunctorKey for MagResult. More...

class	FluxTransform
	Base for flux measurement transformations. More...

class	NoThrowOnNegativeFluxContext
	Temporarily replace negative fluxes with NaNs. More...

struct	FittedModel

class	GaussianCentroidControl
	A C++ control class to handle GaussianCentroidAlgorithm's configuration. More...

class	GaussianCentroidAlgorithm
	A class that calculates a centroid by fitting a circular Gaussian to the image. More...

class	GaussianCentroidTransform

class	GaussianFluxControl
	A C++ control class to handle GaussianFluxAlgorithm's configuration. More...

class	GaussianFluxAlgorithm
	A measurement algorithm that estimates flux using an elliptical Gaussian weight. More...

class	GaussianFluxTransform

class	SafeCentroidExtractor
	Utility class for measurement algorithms that extracts a position from the Centroid slot and handles errors in a safe and consistent way. More...

class	SafeShapeExtractor
	Utility class for measurement algorithms that extracts an ellipse from the Shape slot and handles errors in a safe and consistent way. More...

class	NaiveCentroidControl
	A C++ control class to handle NaiveCentroidAlgorithm's configuration. More...

class	NaiveCentroidAlgorithm
	A class that calculates a centroid as a simple unweighted first moment of the 3x3 region around a pixel. More...

class	NaiveCentroidTransform

class	PeakLikelihoodFluxControl
	C++ control object for peak likelihood flux. More...

class	PeakLikelihoodFluxAlgorithm
	A measurement algorithm that estimates the peak flux, using a filtered image which has been convolved with its own PSF. More...

class	PeakLikelihoodFluxTransform

class	PixelFlagsControl
	A C++ control class to handle PixelFlagsAlgorithm's configuration. More...

class	PixelFlagsAlgorithm
	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...

class	PsfFluxControl
	A C++ control class to handle PsfFluxAlgorithm's configuration. More...

class	PsfFluxAlgorithm
	A measurement algorithm that estimates flux using a linear least-squares fit with the Psf model. More...

class	PsfFluxTransform

class	ScaledApertureFluxControl

class	ScaledApertureFluxAlgorithm
	Measure the flux in an aperture scaled to the PSF. More...

class	ScaledApertureFluxTransform

class	SdssCentroidControl
	A C++ control class to handle SdssCentroidAlgorithm's configuration. More...

class	SdssCentroidAlgorithm
	The Sdss Centroid Algorithm. More...

class	SdssCentroidTransform

class	SdssShapeControl
	A C++ control class to handle SdssShapeAlgorithm's configuration. More...

class	SdssShapeResultKey
	A FunctorKey that maps SdssShapeResult to afw::table Records. More...

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

class	SdssShapeResult
	Result object SdssShapeAlgorithm. More...

class	SdssShapeTransform
	Transformation for SdssShape measurements. More...

struct	ShapeResult
	A reusable struct for moments-based shape measurements. More...

class	ShapeResultKey
	A FunctorKey for ShapeResult. More...

class	SincCoeffs
	A singleton to calculate and cache the coefficients for sinc photometry. More...

class	BaseTransform
	Abstract base class for all C++ measurement transformations. More...

Typedefs

typedef int	ElementCount

typedef double	Flux

typedef double	FluxErrElement

typedef double	Mag

typedef double	MagErrElement

typedef float	ErrElement

typedef double	CentroidElement

typedef double	ShapeElement

typedef afw::geom::Point < CentroidElement, 2 >	Centroid

typedef Eigen::Matrix < ErrElement, 2, 2, Eigen::DontAlign >	CentroidCov

typedef afw::geom::ellipses::Quadrupole	Shape

typedef Eigen::Matrix < ErrElement, 3, 3, Eigen::DontAlign >	ShapeCov

typedef Eigen::Matrix < ShapeElement, 3, 3, Eigen::DontAlign >	ShapeTrMatrix

Enumerations
enum	UncertaintyEnum { NO_UNCERTAINTY = 0, SIGMA_ONLY = 1, FULL_COVARIANCE = 2 }
	An enum used to specify how much uncertainty information measurement algorithms provide. More...

Functions
	LSST_EXCEPTION_TYPE (FatalAlgorithmError, lsst::pex::exceptions::RuntimeError, lsst::meas::base::FatalAlgorithmError)
	Exception to be thrown when a measurement algorithm experiences a fatal error. More...

	LSST_EXCEPTION_TYPE (PixelValueError, lsst::pex::exceptions::DomainError, lsst::meas::base::PixelValueError)
	Exception to be thrown when a measurement algorithm encounters a NaN or infinite pixel. More...

ShapeTrMatrix	makeShapeTransformMatrix (afw::geom::LinearTransform const &xform)
	Construct a matrix suitable for transforming second moments. More...

std::array< FlagDefinition, BlendednessAlgorithm::N_FLAGS > const &	getFlagDefinitions ()

template<typename T >
afw::image::MaskedImage< T > ::SinglePixel	computeShiftedValue (afw::image::MaskedImage< T > const &maskedImage, std::string const &warpingKernelName, afw::geom::Point2D const &fracShift, afw::geom::Point2I const &parentInd)
	Compute the value of one pixel of an image after a fractional pixel shift Since we only want the value at one pixel, there is no need to shift the entire image; instead we simply convolve at one point. More...

Typedef Documentation

typedef afw::geom::Point<CentroidElement,2> lsst::meas::base::Centroid

Definition at line 56 of file constants.h.

typedef Eigen::Matrix<ErrElement,2,2,Eigen::DontAlign> lsst::meas::base::CentroidCov

Definition at line 57 of file constants.h.

typedef double lsst::meas::base::CentroidElement

Definition at line 54 of file constants.h.

typedef int lsst::meas::base::ElementCount

Definition at line 48 of file constants.h.

typedef float lsst::meas::base::ErrElement

Definition at line 53 of file constants.h.

typedef double lsst::meas::base::Flux

Definition at line 49 of file constants.h.

typedef double lsst::meas::base::FluxErrElement

Definition at line 50 of file constants.h.

typedef double lsst::meas::base::Mag

Definition at line 51 of file constants.h.

typedef double lsst::meas::base::MagErrElement

Definition at line 52 of file constants.h.

typedef afw::geom::ellipses::Quadrupole lsst::meas::base::Shape

Definition at line 58 of file constants.h.

typedef Eigen::Matrix<ErrElement,3,3,Eigen::DontAlign> lsst::meas::base::ShapeCov

Definition at line 59 of file constants.h.

typedef double lsst::meas::base::ShapeElement

Definition at line 55 of file constants.h.

typedef Eigen::Matrix<ShapeElement,3,3,Eigen::DontAlign> lsst::meas::base::ShapeTrMatrix

Definition at line 60 of file constants.h.

Enumeration Type Documentation

enum lsst::meas::base::UncertaintyEnum

An enum used to specify how much uncertainty information measurement algorithms provide.

Currently, only ResultMappers (not Results) make use of these distinctions; Result structs always have data members that could hold the full-covariance, but may set some of these to NaN.

Enumerator
NO_UNCERTAINTY	Algorithm provides no uncertainy information at all.
SIGMA_ONLY	Only the diagonal elements of the covariance matrix are provided.
FULL_COVARIANCE	The full covariance matrix is provided.

Definition at line 41 of file constants.h.

                      {
     NO_UNCERTAINTY = 0, 
     SIGMA_ONLY = 1,     
     FULL_COVARIANCE = 2 
 };

Function Documentation

template<typename T >

afw::image::MaskedImage<T>::SinglePixel lsst::meas::base::computeShiftedValue	(	afw::image::MaskedImage< T > const &	maskedImage,
		std::string const &	warpingKernelName,
		afw::geom::Point2D const &	fracShift,
		afw::geom::Point2I const &	parentInd
	)

Compute the value of one pixel of an image after a fractional pixel shift Since we only want the value at one pixel, there is no need to shift the entire image; instead we simply convolve at one point.

Exceptions

pex::exceptions::RangeError if abs(fracShift) > 1 in either dimension

Parameters

maskedImage	masked image
warpingKernelName	warping kernel name
fracShift	amount of sub-pixel shift (pixels)
parentInd	parent index at which to compute pixel

Definition at line 129 of file PeakLikelihoodFlux.cc.

   {
     typedef typename afw::image::Exposure<T>::MaskedImageT MaskedImageT;
     typedef typename afw::image::Image<double> KernelImageT;
 
     PTR(afw::math::SeparableKernel) warpingKernelPtr = afw::math::makeWarpingKernel(warpingKernelName);
 
     if ((std::abs(fracShift[0]) >= 1) || (std::abs(fracShift[1]) >= 1)) {
         std::ostringstream os;
         os << "fracShift = " << fracShift << " too large; abs value must be < 1 in both axes";
         throw LSST_EXCEPT(pex::exceptions::RangeError, os.str());
     }
 
     // warping kernels have even dimension and want the peak to the right of center
     if (fracShift[0] < 0) {
         warpingKernelPtr->setCtrX(warpingKernelPtr->getCtrX() + 1);
     }
     if (fracShift[1] < 0) {
         warpingKernelPtr->setCtrY(warpingKernelPtr->getCtrY() + 1);
     }
     afw::geom::Box2I warpingOverlapBBox(
         parentInd - afw::geom::Extent2I(warpingKernelPtr->getCtr()),
         warpingKernelPtr->getDimensions());
     if (!maskedImage.getBBox().contains(warpingOverlapBBox)) {
         std::ostringstream os;
         os << "Warping kernel extends off the edge"
             << "; kernel bbox = " << warpingOverlapBBox
             << "; exposure bbox = " << maskedImage.getBBox();
         throw LSST_EXCEPT(pex::exceptions::RangeError, os.str());
     }
     warpingKernelPtr->setKernelParameters(std::make_pair(fracShift[0], fracShift[1]));
     KernelImageT warpingKernelImage(warpingKernelPtr->getDimensions());
     warpingKernelPtr->computeImage(warpingKernelImage, true);
     typename KernelImageT::const_xy_locator const warpingKernelLoc = warpingKernelImage.xy_at(0,0);
 
     // Compute imLoc: an image locator that matches kernel locator (0,0) such that
     // image ctrPix overlaps center of warping kernel
     afw::geom::Point2I subimMin = warpingOverlapBBox.getMin();
     typename MaskedImageT::const_xy_locator const mimageLoc = maskedImage.xy_at(subimMin.getX(), subimMin.getY());
     return afw::math::convolveAtAPoint<MaskedImageT, MaskedImageT>(
         mimageLoc, warpingKernelLoc, warpingKernelPtr->getWidth(), warpingKernelPtr->getHeight());
 }

std::array<FlagDefinition,BlendednessAlgorithm::N_FLAGS> const& lsst::meas::base::getFlagDefinitions ( )

Definition at line 215 of file Blendedness.cc.

                                                                                   {
     static std::array<FlagDefinition,BlendednessAlgorithm::N_FLAGS> const flagDefs = {{
         {"flag", "general failure flag"},
         {"flag_noCentroid", "Object has no centroid"},
         {"flag_noShape", "Object has no shape"}
     }};
     return flagDefs;
 }

lsst::meas::base::LSST_EXCEPTION_TYPE	(	FatalAlgorithmError	,
		lsst::pex::exceptions::RuntimeError	,
		lsst::meas::base::FatalAlgorithmError
	)

Exception to be thrown when a measurement algorithm experiences a fatal error.

This error type causes the meas_base framework to throw completely out of the measurement loop which is run for each exposure, sourceCatalog pair.

lsst::meas::base::LSST_EXCEPTION_TYPE	(	PixelValueError	,
		lsst::pex::exceptions::DomainError	,
		lsst::meas::base::PixelValueError
	)

Exception to be thrown when a measurement algorithm encounters a NaN or infinite pixel.

When caught by the plugin framework, this exception will generate a log message.

ShapeTrMatrix lsst::meas::base::makeShapeTransformMatrix ( afw::geom::LinearTransform const & xform )

Construct a matrix suitable for transforming second moments.

Given an LinearTransform which maps from positions (x, y) to (a, d), returns a 3-by-3 matrix which transforms (xx, yy, xy) to (aa, dd, ad).

That is, given an input transform described by the matrix

| A11 | A12 | | A21 | A22 |

we return the matrix

| A11*A11 | A12*A12 | 2*A11*A12 | | A21*A21 | A22*A22 | 2*A21*A22 | | A11*A21 | A12*A22 | A11*A22 + A12*A21 |

Parameters

[in] xform LinearTransform describing the coordinate mapping

Returns: A 3-by-3 transformation matrix for the second order moments

Definition at line 166 of file ShapeUtilities.cc.

                                                                              {
     typedef afw::geom::LinearTransform LT;
     Eigen::Matrix<ShapeElement,3,3,Eigen::DontAlign> m;
     m << xform[LT::XX]*xform[LT::XX], xform[LT::XY]*xform[LT::XY], 2*xform[LT::XX]*xform[LT::XY],
          xform[LT::YX]*xform[LT::YX], xform[LT::YY]*xform[LT::YY], 2*xform[LT::YX]*xform[LT::YY],
          xform[LT::XX]*xform[LT::YX], xform[LT::XY]*xform[LT::YY],
          xform[LT::XX]*xform[LT::YY] + xform[LT::XY]*xform[LT::YX];
     return m;
 }

Namespaces
	apCorrRegistry

	applyApCorr

	baseMeasurement

	catalogCalculation

	classification

	flagDecorator

	forcedMeasurement

	forcedPhotCcd

	forcedPhotCoadd

	forcedPhotImage

	noiseReplacer

	pluginRegistry

	plugins

	pluginsBase

	references

	sfm

	tests

	transforms

	version

	wrappers

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation