lsst::meas::base Namespace Reference

Namespaces
	apCorrRegistry
	applyApCorr
	baseMeasurement
	catalogCalculation
	classification
	footprintArea
	forcedMeasurement
	forcedPhotCcd
	forcedPhotCoadd
	forcedPhotImage
	measurementInvestigationLib
	noiseReplacer
	pluginRegistry
	plugins
	pluginsBase
	python
	references
	sfm
	tests
	transforms
	version
	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	NaiveCentroidAlgorithm
	A class that calculates a centroid as a simple unweighted first moment of the 3x3 region around a pixel. More...
class	NaiveCentroidControl
	A C++ control class to handle NaiveCentroidAlgorithm's configuration. More...
class	NaiveCentroidTransform
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...

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

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
ShapeTrMatrix	makeShapeTransformMatrix (geom::LinearTransform const &xform)
	Construct a matrix suitable for transforming second moments. More...
	PYBIND11_MODULE (algorithm, mod)
	PYBIND11_MODULE (apertureFlux, mod)
	PYBIND11_MODULE (blendedness, mod)
	PYBIND11_MODULE (centroidUtilities, mod)
	PYBIND11_MODULE (circularApertureFlux, mod)
	PYBIND11_MODULE (exceptions, mod)
	PYBIND11_MODULE (flagHandler, mod)
	PYBIND11_MODULE (fluxUtilities, mod)
	PYBIND11_MODULE (gaussianFlux, mod)
	PYBIND11_MODULE (inputUtilities, mod)
	PYBIND11_MODULE (localBackground, mod)
	PYBIND11_MODULE (naiveCentroid, mod)
	PYBIND11_MODULE (peakLikelihoodFlux, mod)
	PYBIND11_MODULE (pixelFlags, mod)
	PYBIND11_MODULE (psfFlux, mod)
	PYBIND11_MODULE (scaledApertureFlux, mod)
	PYBIND11_MODULE (sdssCentroid, mod)
	PYBIND11_MODULE (sdssShape, mod)
	PYBIND11_MODULE (shapeUtilities, mod)
	PYBIND11_MODULE (sincCoeffs, mod)
	PYBIND11_MODULE (transform, mod)
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. More...

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.

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

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

PYBIND11_MODULE() [1/21]

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

Definition at line 35 of file algorithm.cc.

                                {
    py::module::import("lsst.afw.image");
    py::module::import("lsst.afw.table");
 
    py::class_<BaseAlgorithm, std::shared_ptr<BaseAlgorithm>> clsBaseAlgorithm(mod, "BaseAlgorithm");
    py::class_<SingleFrameAlgorithm, std::shared_ptr<SingleFrameAlgorithm>, BaseAlgorithm>
            clsSingleFrameAlgorithm(mod, "SingleFrameAlgorithm");
    py::class_<SimpleAlgorithm, std::shared_ptr<SimpleAlgorithm>, SingleFrameAlgorithm> clsSimpleAlgorithm(
            mod, "SimpleAlgorithm", py::multiple_inheritance());
 
    clsBaseAlgorithm.def("fail", &BaseAlgorithm::fail, "measRecord"_a, "error"_a = NULL);
    clsBaseAlgorithm.def("getLogName", &SimpleAlgorithm::getLogName);
 
    clsSingleFrameAlgorithm.def("measure", &SingleFrameAlgorithm::measure, "record"_a, "exposure"_a);
 
    clsSimpleAlgorithm.def("measureForced", &SimpleAlgorithm::measureForced, "measRecord"_a, "exposure"_a,
                           "refRecord"_a, "refWcs"_a);
}

PYBIND11_MODULE() [2/21]

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

Definition at line 129 of file apertureFlux.cc.

                                   {
    py::module::import("lsst.afw.geom");
    py::module::import("lsst.afw.image");
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.flagHandler");
    py::module::import("lsst.meas.base.fluxUtilities");
    py::module::import("lsst.meas.base.transform");
 
    auto clsFluxControl = declareFluxControl(mod);
    auto clsFluxAlgorithm = declareFluxAlgorithm(mod);
    declareFluxResult(mod);
    auto clsFluxTransform = declareFluxTransform(mod);
 
    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);
}

PYBIND11_MODULE() [3/21]

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

Definition at line 81 of file blendedness.cc.

                                  {
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.flagHandler");
 
    auto clsBlendednessControl = declareBlendednessControl(mod);
    auto clsBlendednessAlgorithm = declareBlendednessAlgorithm(mod);
 
    clsBlendednessAlgorithm.attr("Control") = clsBlendednessControl;
 
    python::declareAlgorithm<BlendednessAlgorithm, BlendednessControl>(clsBlendednessAlgorithm,
                                                                       clsBlendednessControl);
}

PYBIND11_MODULE() [4/21]

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

Definition at line 122 of file centroidUtilities.cc.

                                        {
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.transform");
 
    declareCentroidResult(mod);
    declareCentroidResultKey(mod);
    declareCentroidTransform(mod);
    declareCentroidChecker(mod);
    declareUncertaintyEnum(mod);
}

PYBIND11_MODULE() [5/21]

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

Definition at line 42 of file circularApertureFlux.cc.

                                           {
    py::module::import("lsst.daf.base");
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
 
    PyApertureFluxClass cls(mod, "CircularApertureFluxAlgorithm");
 
    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);
}

PYBIND11_MODULE() [6/21]

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

Definition at line 36 of file exceptions.cc.

                                 {
    using pex::exceptions::python::declareException;
    using pex::exceptions::DomainError;
    using pex::exceptions::RuntimeError;
 
    py::module::import("lsst.pex.exceptions");
 
    auto clsFatalAlgorithmError =
            declareException<FatalAlgorithmError, RuntimeError>(mod, "FatalAlgorithmError", "RuntimeError");
    auto clsMeasurementError =
            declareException<MeasurementError, RuntimeError>(mod, "MeasurementError", "RuntimeError");
    auto clsPixelValueError =
            declareException<PixelValueError, DomainError>(mod, "PixelValueError", "DomainError");
 
    clsMeasurementError.def(py::init<std::string const &, std::size_t>(), "message"_a, "flagBit"_a);
    clsFatalAlgorithmError.def(py::init<std::string const &>(), "message"_a);
    clsPixelValueError.def(py::init<std::string const &>(), "message"_a);
 
    clsMeasurementError.def("getFlagBit", &MeasurementError::getFlagBit);
}

PYBIND11_MODULE() [7/21]

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

Definition at line 121 of file flagHandler.cc.

                                  {
    py::module::import("lsst.afw.table");
 
    declareFlagDefinition(mod);
    declareFlagDefinitionList(mod);
    declareFlagHandler(mod);
}

PYBIND11_MODULE() [8/21]

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

Definition at line 91 of file fluxUtilities.cc.

                                    {
    py::module::import("lsst.afw.table");
 
    declareFluxResult(mod);
    declareFluxResultKey(mod);
    declareMagResult(mod);
    declareMagResultKey(mod);
}

PYBIND11_MODULE() [9/21]

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

Definition at line 81 of file gaussianFlux.cc.

                                   {
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.flagHandler");
    py::module::import("lsst.meas.base.transform");
 
    auto clsFluxControl = declareFluxControl(mod);
    auto clsFluxAlgorithm = declareFluxAlgorithm(mod);
    auto clsFluxTransform = declareFluxTransform(mod);
 
    clsFluxAlgorithm.attr("Control") = clsFluxControl;
    clsFluxTransform.attr("Control") = clsFluxControl;
 
    python::declareAlgorithm<GaussianFluxAlgorithm, GaussianFluxControl, GaussianFluxTransform>(
            clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
}

PYBIND11_MODULE() [10/21]

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

Definition at line 35 of file inputUtilities.cc.

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

PYBIND11_MODULE() [11/21]

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

Definition at line 90 of file localBackground.cc.

                                      {
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.flagHandler");
    py::module::import("lsst.meas.base.fluxUtilities");
    py::module::import("lsst.meas.base.transform");
 
    auto clsControl = declareControl(mod);
    auto clsAlgorithm = declareAlgorithm(mod);
    auto clsTransform = declareTransform(mod);
 
    clsAlgorithm.attr("Control") = clsControl;
    clsTransform.attr("Control") = clsControl;
 
    python::declareAlgorithm<LocalBackgroundAlgorithm, LocalBackgroundControl, LocalBackgroundTransform>(
            clsAlgorithm, clsControl, clsTransform);
}

PYBIND11_MODULE() [12/21]

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

Definition at line 87 of file naiveCentroid.cc.

                                    {
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.flagHandler");
    py::module::import("lsst.meas.base.transform");
 
    auto clsCentroidControl = declareCentroidControl(mod);
    auto clsCentroidAlgorithm = declareCentroidAlgorithm(mod);
    auto clsCentroidTransform = declareCentroidTransform(mod);
 
    clsCentroidAlgorithm.attr("Control") = clsCentroidControl;
    clsCentroidTransform.attr("Control") = clsCentroidControl;
 
    python::declareAlgorithm<NaiveCentroidAlgorithm, NaiveCentroidControl, NaiveCentroidTransform>(
            clsCentroidAlgorithm, clsCentroidControl, clsCentroidTransform);
}

PYBIND11_MODULE() [13/21]

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

Definition at line 80 of file peakLikelihoodFlux.cc.

                                         {
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.flagHandler");
    py::module::import("lsst.meas.base.transform");
 
    auto clsFluxControl = declareFluxControl(mod);
    auto clsFluxAlgorithm = declareFluxAlgorithm(mod);
    auto clsFluxTransform = declareFluxTransform(mod);
 
    clsFluxAlgorithm.attr("Control") = clsFluxControl;
    clsFluxTransform.attr("Control") = clsFluxControl;
 
    python::declareAlgorithm<PeakLikelihoodFluxAlgorithm, PeakLikelihoodFluxControl,
                             PeakLikelihoodFluxTransform>(clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
}

PYBIND11_MODULE() [14/21]

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

Definition at line 40 of file pixelFlags.cc.

                                 {
    py::module::import("lsst.afw.table");
 
    py::class_<PixelFlagsAlgorithm, std::shared_ptr<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);
}

PYBIND11_MODULE() [15/21]

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

Definition at line 84 of file psfFlux.cc.

                              {
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.flagHandler");
    py::module::import("lsst.meas.base.fluxUtilities");
    py::module::import("lsst.meas.base.transform");
 
    auto clsFluxControl = declareFluxControl(mod);
    auto clsFluxAlgorithm = declareFluxAlgorithm(mod);
    auto clsFluxTransform = declareFluxTransform(mod);
 
    clsFluxAlgorithm.attr("Control") = clsFluxControl;
    clsFluxTransform.attr("Control") = clsFluxControl;
 
    python::declareAlgorithm<PsfFluxAlgorithm, PsfFluxControl, PsfFluxTransform>(
            clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
}

PYBIND11_MODULE() [16/21]

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

Definition at line 83 of file scaledApertureFlux.cc.

                                         {
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.fluxUtilities");
    py::module::import("lsst.meas.base.transform");
 
    auto clsFluxControl = declareFluxControl(mod);
    auto clsFluxAlgorithm = declareFluxAlgorithm(mod);
    auto clsFluxTransform = declareFluxTransform(mod);
 
    clsFluxAlgorithm.attr("Control") = clsFluxControl;
    clsFluxTransform.attr("Control") = clsFluxControl;
 
    python::declareAlgorithm<ScaledApertureFluxAlgorithm, ScaledApertureFluxControl,
                             ScaledApertureFluxTransform>(clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
}

PYBIND11_MODULE() [17/21]

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

Definition at line 91 of file sdssCentroid.cc.

                                   {
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.flagHandler");
    py::module::import("lsst.meas.base.transform");
 
    auto clsCentroidControl = declareCentroidControl(mod);
    auto clsCentroidAlgorithm = declareCentroidAlgorithm(mod);
    auto clsCentroidTransform = declareCentroidTransform(mod);
 
    clsCentroidAlgorithm.attr("Control") = clsCentroidControl;
    clsCentroidTransform.attr("Control") = clsCentroidControl;
 
    python::declareAlgorithm<SdssCentroidAlgorithm, SdssCentroidControl, SdssCentroidTransform>(
            clsCentroidAlgorithm, clsCentroidControl, clsCentroidTransform);
}

PYBIND11_MODULE() [18/21]

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

Definition at line 156 of file sdssShape.cc.

                                {
    py::module::import("lsst.afw.geom");
    py::module::import("lsst.afw.table");
    py::module::import("lsst.meas.base.algorithm");
    py::module::import("lsst.meas.base.flagHandler");
    py::module::import("lsst.meas.base.centroidUtilities");  // for CentroidResult
    py::module::import("lsst.meas.base.fluxUtilities");      // for FluxResult
    py::module::import("lsst.meas.base.shapeUtilities");
    py::module::import("lsst.meas.base.transform");
 
    auto clsShapeControl = declareShapeControl(mod);
    declareShapeResultKey(mod);
    auto clsShapeAlgorithm = declareShapeAlgorithm(mod);
    declareShapeResult(mod);
    auto clsShapeTransform = declareShapeTransform(mod);
 
    clsShapeAlgorithm.attr("Control") = clsShapeControl;
    clsShapeTransform.attr("Control") = clsShapeControl;
 
    python::declareAlgorithm<SdssShapeAlgorithm, SdssShapeControl, SdssShapeTransform>(
            clsShapeAlgorithm, clsShapeControl, clsShapeTransform);
}

PYBIND11_MODULE() [19/21]

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

Definition at line 101 of file shapeUtilities.cc.

                                     {
    py::module::import("lsst.afw.table");
 
    declareShapeResult(mod);
    declareShapeResultKey(mod);
 
    mod.def("makeShapeTransformMatrix", &makeShapeTransformMatrix, "xform"_a);
}

PYBIND11_MODULE() [20/21]

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

Definition at line 46 of file sincCoeffs.cc.

                                 {
    py::module::import("lsst.afw.geom");
    py::module::import("lsst.afw.image");
 
    declareSincCoeffs<float>(mod, "F");
    declareSincCoeffs<double>(mod, "D");
}

PYBIND11_MODULE() [21/21]

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

Definition at line 36 of file transform.cc.

                                {
    py::class_<BaseTransform, std::shared_ptr<BaseTransform>> cls(mod, "BaseTransform");
 
    cls.def("__call__", &BaseTransform::operator(), "inputCatalog"_a, "outputCatalog"_a, "wcs"_a,
            "photoCalib"_a);
}