lsst::meas::base Namespace Reference

Namespaces
namespace	_id_generator
namespace	apCorrRegistry
namespace	applyApCorr
namespace	baseMeasurement
namespace	catalogCalculation
namespace	classification
namespace	colorUtilities
namespace	compensatedGaussian
namespace	diaCalculation
namespace	diaCalculationPlugins
namespace	footprintArea
namespace	forcedMeasurement
namespace	forcedPhotCcd
namespace	measurementInvestigationLib
namespace	noiseReplacer
namespace	pluginRegistry
namespace	plugins
namespace	pluginsBase
namespace	python
namespace	sfm
namespace	simple_forced_measurement
namespace	tests
namespace	transforms
namespace	version
namespace	wrappers

Classes
class	ApertureFluxAlgorithm
	Base class for multiple-aperture photometry algorithms. More...
class	ApertureFluxControl
	Configuration object for multiple-aperture flux 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	BaseAlgorithm
	Ultimate abstract base class for all C++ measurement algorithms. More...
class	BaseTransform
	Abstract base class for all C++ measurement transformations. More...
class	BlendednessAlgorithm
	Compute metrics that measure how blended objects are. More...
class	BlendednessControl
class	CentroidChecker
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	CircularApertureFluxAlgorithm
class	FatalAlgorithmError
	Exception to be thrown when a measurement algorithm experiences a fatal error. More...
struct	FlagDefinition
	Simple class used to define and document flags The name and doc constitute the identity of the FlagDefinition The number is used for indexing, but is assigned arbitrarily. More...
class	FlagDefinitionList
	vector-type utility class to build a collection of FlagDefinitions 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 instFlux measurements. More...
class	FluxResultKey
	A FunctorKey for FluxResult. More...
class	FluxTransform
	Base for instFlux measurement transformations. 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	GaussianFluxAlgorithm
	A measurement algorithm that estimates instFlux using an elliptical Gaussian weight. More...
class	GaussianFluxControl
	A C++ control class to handle GaussianFluxAlgorithm's configuration. More...
class	GaussianFluxTransform
class	LocalBackgroundAlgorithm
	A measurement algorithm that estimates the local background value per pixel. More...
class	LocalBackgroundControl
	Configuration of LocalBackgroundAlgorithm. More...
class	LocalBackgroundTransform
struct	MagResult
	A reusable result struct for magnitudes. More...
class	MagResultKey
	A FunctorKey for MagResult. More...
class	MeasurementError
	Exception to be thrown when a measurement algorithm experiences a known failure mode. More...
class	PeakLikelihoodFluxAlgorithm
	A measurement algorithm that estimates the peak instrument flux, using a filtered image which has been convolved with its own PSF. More...
class	PeakLikelihoodFluxControl
	C++ control object for peak likelihood instrument flux. More...
class	PeakLikelihoodFluxTransform
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	PixelFlagsControl
	A C++ control class to handle PixelFlagsAlgorithm's configuration. More...
class	PixelValueError
	Exception to be thrown when a measurement algorithm encounters a NaN or infinite pixel. More...
class	PsfFluxAlgorithm
	A measurement algorithm that estimates instFlux using a linear least-squares fit with the Psf model. More...
class	PsfFluxControl
	A C++ control class to handle PsfFluxAlgorithm's configuration. More...
class	PsfFluxTransform
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	ScaledApertureFluxAlgorithm
	Measure the instFlux in an aperture scaled to the PSF. More...
class	ScaledApertureFluxControl
class	ScaledApertureFluxTransform
class	SdssCentroidAlgorithm
	The Sdss Centroid Algorithm. More...
class	SdssCentroidControl
	A C++ control class to handle SdssCentroidAlgorithm's configuration. More...
class	SdssCentroidTransform
class	SdssShapeAlgorithm
	Measure the image moments of source using adaptive Gaussian weights. More...
class	SdssShapeControl
	A C++ control class to handle SdssShapeAlgorithm's configuration. More...
class	SdssShapeResult
	Result object SdssShapeAlgorithm. More...
class	SdssShapeResultKey
	A FunctorKey that maps SdssShapeResult to afw::table Records. 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	SimpleAlgorithm
	An abstract base classes for which the same implementation can be used for both SingleFrameAlgorithm and ForcedAlgorithm. More...
class	SincCoeffs
	A singleton to calculate and cache the coefficients for sinc photometry. More...
class	SingleFrameAlgorithm
	Base class for algorithms that measure the properties of sources on single image. More...
class	WrapperCollection
	A helper class for subdividing pybind11 module across multiple translation units (i.e. 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 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
using	PyApertureFluxClass = py::classh<CircularApertureFluxAlgorithm, ApertureFluxAlgorithm>

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
std::ostream &	operator<< (std::ostream &os, CentroidResult const &result)
std::ostream &	operator<< (std::ostream &os, FluxResult const &result)
ShapeTrMatrix	makeShapeTransformMatrix (geom::LinearTransform const &xform)
	Construct a matrix suitable for transforming second moments.
void	wrapFluxUtilities (WrapperCollection &)
void	wrapAlgorithm (WrapperCollection &)
void	wrapApertureFlow (WrapperCollection &)
void	wrapBlendedness (WrapperCollection &)
void	wrapCentroidUtilities (WrapperCollection &)
void	wrapCircularApertureFlux (WrapperCollection &)
void	wrapExceptions (WrapperCollection &)
void	wrapFlagHandler (WrapperCollection &)
void	wrapGaussianFlux (WrapperCollection &)
void	wrapInputUtilities (WrapperCollection &)
void	wrapLocalBackground (WrapperCollection &)
void	wrapPeakLikelihoodFlux (WrapperCollection &)
void	wrapPixelFLags (WrapperCollection &)
void	wrapPsfFlux (WrapperCollection &)
void	wrapScaledApertureFlux (WrapperCollection &)
void	wrapSddsCentroid (WrapperCollection &)
void	wrapShapeUtilities (WrapperCollection &)
void	wrapSincCoeffs (WrapperCollection &)
void	wrapSsdsShape (WrapperCollection &)
void	wrapTransform (WrapperCollection &)
void	wrapCalcCompensatedGaussian (WrapperCollection &)
	PYBIND11_MODULE (_measBaseLib, mod)
py::tuple	compensated_gaussian_filt_inner_product (py::array_t< double, py::array::c_style|py::array::forcecast > &array, py::array_t< double, py::array::c_style|py::array::forcecast > &variance_array, double x_mean, double y_mean, double sig, double t)
template<typename T>
afw::image::MaskedImage< T >::SinglePixel	computeShiftedValue (afw::image::MaskedImage< T > const &maskedImage, std::string const &warpingKernelName, geom::Point2D const &fracShift, 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.

Typedef Documentation

Centroid

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

Definition at line 58 of file constants.h.

CentroidCov

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

Definition at line 59 of file constants.h.

CentroidElement

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

Definition at line 56 of file constants.h.

ElementCount

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

Definition at line 50 of file constants.h.

ErrElement

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

Definition at line 55 of file constants.h.

Flux

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

Definition at line 51 of file constants.h.

FluxErrElement

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

Definition at line 52 of file constants.h.

Mag

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

Definition at line 53 of file constants.h.

MagErrElement

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

Definition at line 54 of file constants.h.

PyApertureFluxClass

using lsst::meas::base::PyApertureFluxClass = py::classh<CircularApertureFluxAlgorithm, ApertureFluxAlgorithm>

Definition at line 35 of file circularApertureFlux.cc.

Shape

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

Definition at line 60 of file constants.h.

ShapeCov

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

Definition at line 61 of file constants.h.

ShapeElement

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

Definition at line 57 of file constants.h.

ShapeTrMatrix

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

Definition at line 62 of file constants.h.

Enumeration Type Documentation

UncertaintyEnum

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 43 of file constants.h.

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

Function Documentation

compensated_gaussian_filt_inner_product()

py::tuple lsst::meas::base::compensated_gaussian_filt_inner_product	(	py::array_t< double, py::array::c_style|py::array::forcecast > &	array,
		py::array_t< double, py::array::c_style|py::array::forcecast > &	variance_array,
		double	x_mean,
		double	y_mean,
		double	sig,
		double	t )

Definition at line 14 of file _calcCompensatedGaussian.cc.

                                                                                                      {
    //Verify the input array is conditioned in an appropriate manner.
    py::buffer_info buffer = array.request();
    py::buffer_info variance_buffer = variance_array.request();
 
    if (buffer.ndim != 2) {
        throw std::runtime_error("Number of dimensions for array must be 2");
    }
    if (buffer.shape[0] != buffer.shape[1]){
        throw std::runtime_error("Array must be square");
    }
    if (!(buffer.shape[0] % 2)) {
        throw std::runtime_error("Number of pixels along array side must be odd");
    }
 
    if (variance_buffer.ndim != buffer.ndim) {
        throw std::runtime_error("Variance array must have same dimensions as image array");
    }
    if (variance_buffer.shape[0] != buffer.shape[0] || variance_buffer.shape[1] != buffer.shape[1]) {
        throw std::runtime_error("Variance array must have same dimensions as image array");
    }
 
    double sig_sq = sig*sig;
    double t_sq_inv = 1./(t*t);
    double t_inv = 1./t;
 
    // fast access to array since we know all the bounds are appropriate
    auto array_unchecked = array.unchecked<2>();
    auto variance_array_unchecked = variance_array.unchecked<2>();
 
    // declare most variables that will be used
    double flux = 0;
    double x_offset_sq;
    double y_offset_sq;
    double y_component;
    double y_component_out;
    double tmp_x_div;
    double tmp_y_div;
    double two_sig_sq = 2*sig_sq;
 
    int half_domain = floor(buffer.shape[0] / 2);
    int stop = buffer.shape[0];
 
    // adjust the x and y center to be centered about the middle of the array
    x_mean -= (double) half_domain;
    y_mean -= (double) half_domain;
 
    /*
    create containers to store the 1 dimensional x calculations, these will be
    accessed for each loop in y, no need to do the same calculations each time
    */
    std::vector<float> x_container;
    std::vector<float> x_container_out;
    x_container.reserve(stop);
    x_container_out.reserve(stop);
 
    // for weighted variance calculation
    double variance = 0;
    double var_norm = 0;
 
    // calculate the x profile
    for (int j = 0; j < stop; ++j) {
        double x_pos = j - half_domain;
        x_offset_sq = -1*pow(x_pos - x_mean, 2);
        tmp_x_div = x_offset_sq / two_sig_sq;
        x_container.push_back(exp(tmp_x_div));
        x_container_out.push_back(t_inv * exp(tmp_x_div * t_sq_inv));
    }
 
    // for each y row, go over the saved x vector accumulating the inner
    // product.
    for (int i = 0; i < stop; ++i) {
        double y_pos = i - half_domain;
        y_offset_sq = -1*pow(y_pos - y_mean, 2);
        tmp_y_div = y_offset_sq / two_sig_sq;
        y_component = exp(tmp_y_div);
        y_component_out = t_inv * exp(tmp_y_div * t_sq_inv);
        for (int j = 0; j < stop; ++j){
            double weight = (y_component*x_container[j] - y_component_out*x_container_out[j]);
            double weighted_value = weight*array_unchecked(i, j);
            flux += weighted_value;
 
            variance += weight*weight*variance_array_unchecked(i, j);
            var_norm += weight*weight;
        }
    }
 
    // Normalization of the normalized Gaussian filter is 4 * pi * sig**2 * (t**2 + 1)/(t**2 - 1)
    // We have deliberately not applied the normalization factor 1. / (2 * pi * sig**2) in the
    // inner product, leaving the normalization term as 2 * (t**2 + 1)/(t**2 - 1) for the
    // flux, and XXX for the variance.
    flux *= 2 * (t*t + 1) / (t*t - 1);
 
    // The variance has been normalized and so requires the full normalization term.
    variance /= var_norm;
    variance *= (4 * M_PI * sig_sq * (t*t + 1) ) / (t*t);
 
    return py::make_tuple(flux, variance);
}

computeShiftedValue()

template<typename T>

afw::image::MaskedImage< T >::SinglePixel lsst::meas::base::computeShiftedValue	(	afw::image::MaskedImage< T > const &	maskedImage,
		std::string const &	warpingKernelName,
		geom::Point2D const &	fracShift,
		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 134 of file PeakLikelihoodFlux.cc.

          {
    typedef typename afw::image::Exposure<T>::MaskedImageT MaskedImageT;
    typedef typename afw::image::Image<double> KernelImageT;
 
std::shared_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->setCtr(warpingKernelPtr->getCtr() + geom::Extent2I(1, 0));
    }
    if (fracShift[1] < 0) {
        warpingKernelPtr->setCtr(warpingKernelPtr->getCtr() + geom::Extent2I(0, 1));
    }
    geom::Box2I warpingOverlapBBox(parentInd - 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
    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());
}

makeShapeTransformMatrix()

ShapeTrMatrix lsst::meas::base::makeShapeTransformMatrix

(

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 143 of file ShapeUtilities.cc.

                                                                         {
    typedef 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;
}

operator<<() [1/2]

std::ostream & lsst::meas::base::operator<<	(	std::ostream &	os,
		CentroidResult const &	result )

Definition at line 66 of file CentroidUtilities.cc.

                                                                     {
    os << "x=" << result.x << ", y=" << result.y << ", xErr=" << result.xErr << ", yErr=" << result.yErr;
    return os;
}

operator<<() [2/2]

std::ostream & lsst::meas::base::operator<<	(	std::ostream &	os,
		FluxResult const &	result )

Definition at line 57 of file FluxUtilities.cc.

                                                                 {
    os << "instFlux=" << result.instFlux << ", instFluxErr=" << result.instFluxErr;
    return os;
}

PYBIND11_MODULE()

lsst::meas::base::PYBIND11_MODULE	(	_measBaseLib	,
		mod	)

Definition at line 58 of file _measBaseLib.cc.

                                   {
    lsst::cpputils::python::WrapperCollection wrappers(mod, "lsst.meas.base");
 
    wrappers.addInheritanceDependency("lsst.afw.geom");
    wrappers.addInheritanceDependency("lsst.afw.image");
    wrappers.addInheritanceDependency("lsst.afw.table");
    wrappers.addInheritanceDependency("lsst.pex.exceptions");
 
    wrappers.addSignatureDependency("lsst.daf.base");
 
    wrapExceptions(wrappers);
    wrapFlagHandler(wrappers);
    wrapFluxUtilities(wrappers);
    wrapTransform(wrappers);
    wrapAlgorithm(wrappers);
    wrapApertureFlow(wrappers);
    wrapBlendedness(wrappers);
    wrapCentroidUtilities(wrappers);
    wrapCircularApertureFlux(wrappers);
    wrapGaussianFlux(wrappers);
    wrapInputUtilities(wrappers);
    wrapLocalBackground(wrappers);
    wrapPeakLikelihoodFlux(wrappers);
    wrapPixelFLags(wrappers);
    wrapPsfFlux(wrappers);
    wrapScaledApertureFlux(wrappers);
    wrapSddsCentroid(wrappers);
    wrapShapeUtilities(wrappers);
    wrapSincCoeffs(wrappers);
    wrapSsdsShape(wrappers);
    wrapCalcCompensatedGaussian(wrappers);
    wrappers.finish();
}

wrapAlgorithm()

void lsst::meas::base::wrapAlgorithm

(

WrapperCollection &

wrappers

)

Definition at line 65 of file algorithm.cc.

                                                                  {
    declareBaseAlgorithm(wrappers);
    declareSingleFrameAlgorithm(wrappers);
    declareSimpleAlgorithm(wrappers);
}

wrapApertureFlow()

void lsst::meas::base::wrapApertureFlow

(

WrapperCollection &

wrappers

)

Definition at line 122 of file apertureFlux.cc.

                                                                     {
    auto clsFluxControl = declareFluxControl(wrappers);
    auto clsFluxAlgorithm = declareFluxAlgorithm(wrappers);
    declareFluxResult(wrappers);
    auto clsFluxTransform = declareFluxTransform(wrappers);
 
    clsFluxAlgorithm.attr("Control") = clsFluxControl;
    // no need to make ApertureFluxControl::Result visible to Python
    clsFluxTransform.attr("Control") = clsFluxControl;
 
    python::declareAlgorithm<ApertureFluxAlgorithm, ApertureFluxControl, ApertureFluxTransform>(
            clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
}

wrapBlendedness()

void lsst::meas::base::wrapBlendedness

(

WrapperCollection &

wrappers

)

Definition at line 77 of file blendedness.cc.

                                                                    {
    auto clsBlendednessControl = declareBlendednessControl(wrappers);
    auto clsBlendednessAlgorithm = declareBlendednessAlgorithm(wrappers);
    clsBlendednessAlgorithm.attr("Control") = clsBlendednessControl;
 
    python::declareAlgorithm<BlendednessAlgorithm, BlendednessControl>(clsBlendednessAlgorithm,
                                                                       clsBlendednessControl);
}

wrapCalcCompensatedGaussian()

void lsst::meas::base::wrapCalcCompensatedGaussian

(

WrapperCollection &

wrappers

)

Definition at line 116 of file _calcCompensatedGaussian.cc.

                                                                                {
    wrappers.wrap([](auto &mod) {
        mod.def("_compensatedGaussianFiltInnerProduct", &compensated_gaussian_filt_inner_product,
R"doc_string(Calculates flux and variance for a Compensated Gaussian filter.
 
Parameters

wrapCentroidUtilities()

void lsst::meas::base::wrapCentroidUtilities

(

WrapperCollection &

wrappers

)

Definition at line 125 of file centroidUtilities.cc.

                                                                          {
    declareCentroidResult(wrappers);
    declareCentroidResultKey(wrappers);
    declareCentroidTransform(wrappers);
    declareCentroidChecker(wrappers);
    declareUncertaintyEnum(wrappers);
}

wrapCircularApertureFlux()

void lsst::meas::base::wrapCircularApertureFlux

(

WrapperCollection &

wrappers

)

Definition at line 36 of file circularApertureFlux.cc.

                                                                              {
 
    wrappers.wrapType(PyApertureFluxClass(wrappers.module,  "CircularApertureFluxAlgorithm"), [](auto &mod, auto &cls) {
        cls.def(py::init<CircularApertureFluxAlgorithm::Control const &, std::string const &,
                        afw::table::Schema &, daf::base::PropertySet &>(),
                "ctrl"_a, "name"_a, "schema"_a, "metadata"_a);
        cls.def("measure", &CircularApertureFluxAlgorithm::measure, "measRecord"_a, "exposure"_a);
    });
}

wrapExceptions()

void lsst::meas::base::wrapExceptions

(

WrapperCollection &

wrappers

)

Definition at line 36 of file exceptions.cc.

                                                                   {
    using pex::exceptions::python::declareException;
    using pex::exceptions::DomainError;
    using pex::exceptions::RuntimeError;
 
 
    wrappers.wrapType(
            declareException<FatalAlgorithmError, RuntimeError>(wrappers.module, "FatalAlgorithmError", "RuntimeError"),
            [](auto &mod, auto &cls) {
                cls.def(py::init<std::string const &>(), "message"_a);
            });
    wrappers.wrapType(
            declareException<MeasurementError, RuntimeError>(wrappers.module, "MeasurementError", "RuntimeError"),
            [](auto &mod, auto &cls) {
                cls.def(py::init<std::string const &, std::size_t>(), "message"_a, "flagBit"_a);
                cls.def("getFlagBit", &MeasurementError::getFlagBit);
            });
    wrappers.wrapType(
            declareException<PixelValueError, DomainError>(wrappers.module, "PixelValueError", "DomainError"),
            [](auto &mod, auto &cls) {
                cls.def(py::init<std::string const &>(), "message"_a);
             });
}

wrapFlagHandler()

void lsst::meas::base::wrapFlagHandler

(

WrapperCollection &

wrappers

)

Definition at line 124 of file flagHandler.cc.

                                                                    {
    declareFlagDefinition(wrappers);
    declareFlagDefinitionList(wrappers);
    declareFlagHandler(wrappers);
}

wrapFluxUtilities()

void lsst::meas::base::wrapFluxUtilities

(

WrapperCollection &

wrappers

)

Definition at line 97 of file fluxUtilities.cc.

                                                                      {
    declareFluxResult(wrappers);
    declareFluxResultKey(wrappers);
    declareMagResult(wrappers);
    declareMagResultKey(wrappers);
}

wrapGaussianFlux()

void lsst::meas::base::wrapGaussianFlux

(

WrapperCollection &

wrappers

)

Definition at line 76 of file gaussianFlux.cc.

                                                                     {
    auto clsFluxControl = declareFluxControl(wrappers);
    auto clsFluxAlgorithm = declareFluxAlgorithm(wrappers);
    auto clsFluxTransform = declareFluxTransform(wrappers);
 
    clsFluxAlgorithm.attr("Control") = clsFluxControl;
    clsFluxTransform.attr("Control") = clsFluxControl;
 
    python::declareAlgorithm<GaussianFluxAlgorithm, GaussianFluxControl, GaussianFluxTransform>(
            clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
}

wrapInputUtilities()

void lsst::meas::base::wrapInputUtilities

(

WrapperCollection &

wrappers

)

Definition at line 36 of file inputUtilities.cc.

                                                                       {
    using PySafeCentroidExtractor = py::class_<SafeCentroidExtractor>;
    wrappers.wrapType(PySafeCentroidExtractor(wrappers.module, "SafeCentroidExtractor"), [](auto &mod, auto &cls) {
        cls.def(py::init<afw::table::Schema &, std::string const &, bool>(), "schema"_a,
                "name"_a, "isCentroider"_a = false);
        cls.def("__call__",
                [](SafeCentroidExtractor const &self, afw::table::SourceRecord &record,
                   FlagHandler const &flags) { return self(record, flags); },
                "record"_a, "flags"_a);
    });
}

wrapLocalBackground()

void lsst::meas::base::wrapLocalBackground

(

WrapperCollection &

wrappers

)

Definition at line 85 of file localBackground.cc.

                                                                        {
    auto clsControl = declareControl(wrappers);
    auto clsAlgorithm = declareAlgorithm(wrappers);
    auto clsTransform = declareTransform(wrappers);
 
    clsAlgorithm.attr("Control") = clsControl;
    clsTransform.attr("Control") = clsControl;
 
    python::declareAlgorithm<LocalBackgroundAlgorithm, LocalBackgroundControl, LocalBackgroundTransform>(
            clsAlgorithm, clsControl, clsTransform);
}

wrapPeakLikelihoodFlux()

void lsst::meas::base::wrapPeakLikelihoodFlux

(

WrapperCollection &

wrappers

)

Definition at line 75 of file peakLikelihoodFlux.cc.

                                                                           {
    wrappers.addSignatureDependency("lsst.afw.table");
    wrappers.addSignatureDependency("lsst.afw.image");
 
    auto clsFluxControl = declareFluxControl(wrappers);
    auto clsFluxAlgorithm = declareFluxAlgorithm(wrappers);
    auto clsFluxTransform = declareFluxTransform(wrappers);
 
    clsFluxAlgorithm.attr("Control") = clsFluxControl;
    clsFluxTransform.attr("Control") = clsFluxControl;
 
    python::declareAlgorithm<PeakLikelihoodFluxAlgorithm, PeakLikelihoodFluxControl,
            PeakLikelihoodFluxTransform>(clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
}

wrapPixelFLags()

void lsst::meas::base::wrapPixelFLags

(

WrapperCollection &

wrappers

)

Definition at line 41 of file pixelFlags.cc.

                                                                   {
    wrappers.wrap([](auto &mod) {
        py::classh<PixelFlagsAlgorithm, SimpleAlgorithm>
                clsPixelFlagsAlgorithm(mod, "PixelFlagsAlgorithm");
        py::class_<PixelFlagsControl> clsPixelFlagsControl(mod, "PixelFlagsControl");
 
        clsPixelFlagsAlgorithm.def(
                py::init<PixelFlagsAlgorithm::Control const &, std::string const &, afw::table::Schema &>(),
                "ctrl"_a, "name"_a, "schema"_a);
 
        clsPixelFlagsControl.def(py::init<>());
 
        clsPixelFlagsAlgorithm.def("measure", &PixelFlagsAlgorithm::measure, "measRecord"_a, "exposure"_a);
        clsPixelFlagsAlgorithm.def("fail", &PixelFlagsAlgorithm::fail, "measRecord"_a, "error"_a = nullptr);
 
        LSST_DECLARE_CONTROL_FIELD(clsPixelFlagsControl, PixelFlagsControl, masksFpAnywhere);
        LSST_DECLARE_CONTROL_FIELD(clsPixelFlagsControl, PixelFlagsControl, masksFpCenter);
    });
}

wrapPsfFlux()

void lsst::meas::base::wrapPsfFlux

(

WrapperCollection &

wrappers

)

Definition at line 81 of file psfFlux.cc.

                                                                {
    auto clsFluxControl = declareFluxControl(wrappers);
    auto clsFluxAlgorithm = declareFluxAlgorithm(wrappers);
    auto clsFluxTransform = declareFluxTransform(wrappers);
    clsFluxAlgorithm.attr("Control") = clsFluxControl;
    clsFluxTransform.attr("Control") = clsFluxControl;
 
    python::declareAlgorithm<PsfFluxAlgorithm, PsfFluxControl, PsfFluxTransform>(
            clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
}

wrapScaledApertureFlux()

void lsst::meas::base::wrapScaledApertureFlux

(

WrapperCollection &

wrappers

)

Definition at line 80 of file scaledApertureFlux.cc.

                                                                           {
    auto clsFluxControl = declareFluxControl(wrappers);
    auto clsFluxAlgorithm = declareFluxAlgorithm(wrappers);
    auto clsFluxTransform = declareFluxTransform(wrappers);
 
    clsFluxAlgorithm.attr("Control") = clsFluxControl;
    clsFluxTransform.attr("Control") = clsFluxControl;
 
    python::declareAlgorithm<ScaledApertureFluxAlgorithm, ScaledApertureFluxControl,
            ScaledApertureFluxTransform>(clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
}

wrapSddsCentroid()

void lsst::meas::base::wrapSddsCentroid

(

WrapperCollection &

wrappers

)

Definition at line 86 of file sdssCentroid.cc.

                                                                     {
    auto clsCentroidControl = declareCentroidControl(wrappers);
    auto clsCentroidAlgorithm = declareCentroidAlgorithm(wrappers);
    auto clsCentroidTransform = declareCentroidTransform(wrappers);
 
    clsCentroidAlgorithm.attr("Control") = clsCentroidControl;
    clsCentroidTransform.attr("Control") = clsCentroidControl;
 
    python::declareAlgorithm<SdssCentroidAlgorithm, SdssCentroidControl, SdssCentroidTransform>(
            clsCentroidAlgorithm, clsCentroidControl, clsCentroidTransform);
}

wrapShapeUtilities()

void lsst::meas::base::wrapShapeUtilities

(

WrapperCollection &

wrappers

)

Definition at line 98 of file shapeUtilities.cc.

                                                                       {
    declareShapeResult(wrappers);
    declareShapeResultKey(wrappers);
    wrappers.wrap([](auto &mod) {
        mod.def("makeShapeTransformMatrix", &makeShapeTransformMatrix, "xform"_a);
    });
}

wrapSincCoeffs()

void lsst::meas::base::wrapSincCoeffs

(

WrapperCollection &

wrappers

)

Definition at line 48 of file sincCoeffs.cc.

                                                                   {
    declareSincCoeffs<float>(wrappers, "F");
    declareSincCoeffs<double>(wrappers, "D");
}

wrapSsdsShape()

void lsst::meas::base::wrapSsdsShape

(

WrapperCollection &

wrappers

)

Definition at line 148 of file sdssShape.cc.

                                                                  {
    auto clsShapeControl = declareShapeControl(wrappers);
    declareShapeResultKey(wrappers);
    auto clsShapeAlgorithm = declareShapeAlgorithm(wrappers);
    declareShapeResult(wrappers);
    auto clsShapeTransform = declareShapeTransform(wrappers);
 
    clsShapeAlgorithm.attr("Control") = clsShapeControl;
    clsShapeTransform.attr("Control") = clsShapeControl;
 
    python::declareAlgorithm<SdssShapeAlgorithm, SdssShapeControl, SdssShapeTransform>(
            clsShapeAlgorithm, clsShapeControl, clsShapeTransform);
}

wrapTransform()

void lsst::meas::base::wrapTransform

(

WrapperCollection &

wrappers

)

Definition at line 37 of file transform.cc.

                                                                  {
    using PyBaseTransform = py::classh<BaseTransform>;
    wrappers.wrapType(PyBaseTransform(wrappers.module, "BaseTransform"), [](auto &mod, auto &cls) {
        cls.def("__call__", &BaseTransform::operator(), "inputCatalog"_a, "outputCatalog"_a, "wcs"_a,
                "photoCalib"_a);
    });
}