lsst::shapelet Namespace Reference

Namespaces
namespace	constants
namespace	generator
namespace	multiShapeletFunction
namespace	radialProfile
namespace	shapeletFunction
namespace	tests
namespace	tractor
namespace	version

Classes
class	BasisEvaluator
	Evaluates a standard shapelet Basis. More...
class	ConversionMatrix
	Conversions between shapelet basis types. More...
class	GaussHermiteConvolution
	A parametrized matrix that performs a convolution in shapelet space. More...
class	GaussHermiteEvaluator
	A class to evaluate HERMITE shapelet-related quantities. More...
class	GaussHermiteProjection
class	HermiteTransformMatrix
	A class that computes a matrix that applies a linear transform to a 2-d Hermite polynomial expansion. More...
class	MatrixBuilder
	Class that evaluates a (multi-)shapelet basis at predefined points. More...
class	MatrixBuilderFactory
	A factory class for MatrixBuilder, providing more control over workspace memory. More...
class	MatrixBuilderWorkspace
	Reusable, shareable workspace for MatrixBuilder. More...
class	MultiShapeletBasis
	A basis formed from a linear combination of shapelet bases that differ only in radius. More...
class	MultiShapeletBasisComponent
	Simple struct that represents one shapelet expansion in a MultiShapeletBasis. More...
class	MultiShapeletFunction
	A multi-scale shapelet function. More...
class	MultiShapeletFunctionEvaluator
	Evaluates a MultiShapeletFunction. More...
class	MultiShapeletFunctionKey
	Class that maps MultiShapeletFunction objects to fields in afw::table objects. More...
class	PackedIndex
	An iterator-like object to help in traversing "packed" shapelet or Hermite polynomial matrix or vector dimensions. More...
class	RadialProfile
	Registry and utility class for multi-Gaussian approximations to radial profiles. More...
class	ShapeletFunction
	A 2-d function defined by an expansion onto a Gauss-Laguerre or Gauss-Hermite basis. More...
class	ShapeletFunctionEvaluator
	Evaluates a ShapeletFunction. More...
class	ShapeletFunctionKey
	Class that maps ShapeletFunction objects to fields in afw::table objects. More...

Typedefs
typedef afw::geom::ellipses::Quadrupole	EllipseCore
typedef ndarray::Array< double, 1 >	Array1d
	Typedef for a commonly-used array type.

Enumerations
enum	BasisTypeEnum { HERMITE , LAGUERRE }
	An enum that sets whether to use real-valued polar shapelets or Cartesian shapelets. More...

Functions
int	computeOffset (int order)
	Return the offset of the given order in a coefficient vector.
int	computeSize (int order)
	Return the size of the coefficient vector for the given order.
int	computeOrder (int size)
	Infer the order of a shapelet expansion from the number of coefficients.
double	intSqrt (int n)
	Compute the square root of an integer number.
double	rationalSqrt (int n, int d)
	Compute the square root of a rational number i.e. sqrt(n/d)
void	wrapConstants (WrapperCollection &wrappers)
void	wrapMatrixBuilder (WrapperCollection &wrappers)
void	wrapGaussHermiteConvolution (WrapperCollection &wrappers)
void	wrapFunctorKeys (WrapperCollection &wrappers)
void	wrapShapeletFunction (WrapperCollection &wrappers)
void	wrapGaussHermiteProjection (WrapperCollection &wrappers)
void	wrapMultiShapeletFunction (WrapperCollection &wrappers)
void	wrapHermiteTransformMatrix (WrapperCollection &wrappers)
void	wrapMultiShapeletBasis (WrapperCollection &wrappers)
void	wrapBasisEvaluator (WrapperCollection &wrappers)
void	wrapRadialProfile (WrapperCollection &wrappers)
	PYBIND11_MODULE (_shapeletLib, mod)

Variables
double const	BASIS_NORMALIZATION
	Normalization factor for 1-d orthonormal shapelets: pi^(-1/4)

Detailed Description

lsst.shapelet

Typedef Documentation

Array1d

typedef ndarray::Array<double,1> lsst::shapelet::Array1d

Typedef for a commonly-used array type.

Note

Serves as a workaround for ambiguities in the C++ standard itself: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#325

Definition at line 121 of file constants.h.

EllipseCore

typedef afw::geom::ellipses::Quadrupole lsst::shapelet::EllipseCore

Definition at line 44 of file constants.h.

Enumeration Type Documentation

BasisTypeEnum

enum lsst::shapelet::BasisTypeEnum

An enum that sets whether to use real-valued polar shapelets or Cartesian shapelets.

The conversion between the two bases is theoretically exact, but of course subject to round-off error here.

Enumerator
HERMITE	Cartesian shapelets or Gauss-Hermite functions, as defined in Refregier, 2003. That is, $\psi(x, y)_{n_x, n_y} = \frac{H_{n_x}(x) H_{n_y}(y) e^{-\frac{x^2 + y^2}{2}}} {\sigma 2^{n_x + n_y} \sqrt{\pi n_x! n_y!}}$ where $H_n(x)$ is a Hermite polynomial. The ordering of coefficients [n_x, n_y] is (row-major packed): [0,0], [0,1], [1,0], [0,2], [1,1], [2,0], [0,3], [1,2], [2,1], [3,0], [0,4], [1,3], [2,2], [3,1], [4,0] etc.
LAGUERRE	Polar shapelets or Gauss-Laguerre functions, as defined in Bernstein and Jarvis, 2002. That is, $\psi(x, y, \sigma)_{p, q} = (-1)^q \sqrt{\frac{q!}{p!}} (x + i y)^{p-q} e^{-\frac{x^2 + y^2}{2}} L^{(p-q)}_q(x^2 + y^2)$ where $L^{(m)}_n(r)$ is an associated Laguerre polynomial. The ordering of coefficients [p, q] is (row-major packed): [0,0], Re([1,0]), Im([1,0]), Re([2,0]), Im([2,0]), [1,1], Re([3,0]), Im([3,0], Re([2,1]), Im([2,1]), Re([4,0]), Im([4,0], Re([3,1]), Im([3,1]), [2,2] etc. Elements with p < q are redundant in representing real-valued functions, while those with p == q are inherently real.

Definition at line 52 of file constants.h.

                   {
    HERMITE, 
 
    LAGUERRE, 
};

Function Documentation

computeOffset()

int lsst::shapelet::computeOffset ( int order )

inline

Return the offset of the given order in a coefficient vector.

Definition at line 94 of file constants.h.

{ return order * (order + 1) / 2; }

computeOrder()

int lsst::shapelet::computeOrder ( int size )

inline

Infer the order of a shapelet expansion from the number of coefficients.

Exceptions

InvalidParameterError

if the number of coefficients does not correspond to any shapelet order.

Definition at line 104 of file constants.h.

                                  {
    int order = (std::sqrt(8*size + 1) - 3)/2;
    if (computeSize(order) != size) {
        throw LSST_EXCEPT(
            pex::exceptions::InvalidParameterError,
            "Invalid size for shapelet coefficient matrix"
        );
    }
    return order;
}

computeSize()

int lsst::shapelet::computeSize ( int order )

inline

Return the size of the coefficient vector for the given order.

Definition at line 97 of file constants.h.

{ return computeOffset(order + 1); }

intSqrt()

double lsst::shapelet::intSqrt ( int n )

inline

Compute the square root of an integer number.

Definition at line 124 of file constants.h.

                             {
    return std::sqrt(double(n));
}

PYBIND11_MODULE()

lsst::shapelet::PYBIND11_MODULE	(	_shapeletLib	,
		mod	)

Definition at line 46 of file _shapeletLib.cc.

                                   {
    WrapperCollection wrappers(mod, "lsst.shapelet");
 
    wrappers.addInheritanceDependency("lsst.afw.table");
 
    wrappers.addSignatureDependency("lsst.geom");
    wrappers.addSignatureDependency("lsst.afw.geom");
    wrappers.addSignatureDependency("lsst.afw.image");
 
    wrapConstants(wrappers);
    wrapMatrixBuilder(wrappers);
    wrapGaussHermiteConvolution(wrappers);
    wrapFunctorKeys(wrappers);
    wrapShapeletFunction(wrappers);
    wrapGaussHermiteProjection(wrappers);
    wrapMultiShapeletFunction(wrappers);
    wrapHermiteTransformMatrix(wrappers);
    wrapMultiShapeletBasis(wrappers);
    wrapBasisEvaluator(wrappers);
    wrapRadialProfile(wrappers);
    wrappers.finish();
}

rationalSqrt()

double lsst::shapelet::rationalSqrt ( int n, int d )

inline

Compute the square root of a rational number i.e. sqrt(n/d)

Definition at line 129 of file constants.h.

                                         {
    return std::sqrt(double(n) / double(d));
}

wrapBasisEvaluator()

void lsst::shapelet::wrapBasisEvaluator

(

WrapperCollection &

wrappers

)

Definition at line 35 of file basisEvaluator.cc.

                                                                       {
    using PyBasisEvaluator = py::class_<BasisEvaluator, std::shared_ptr<BasisEvaluator>>;
 
    wrappers.wrapType(PyBasisEvaluator(wrappers.module, "BasisEvaluator"), [](auto &mod, auto &cls) {
        /* Constructors */
        cls.def(py::init<int, BasisTypeEnum>(), "order"_a, "basisType"_a);
 
        /* Members */
        cls.def("getOrder", &BasisEvaluator::getOrder);
        cls.def("getBasisType", &BasisEvaluator::getBasisType);
 
        /* fillEvaluation has default constructed Array1d objects as keyword
         * arguments.
         * Unfortunately, for some reason array.isEmpty() == false even with 0
         * elements,
         * which leads to a segfault.
         * Thus we must delegate through lambdas instead. */
        cls.def("fillEvaluation", [](BasisEvaluator &self, Array1d const &array, double x,
                                                   double y) { return self.fillEvaluation(array, x, y); },
                              "array"_a, "x"_a, "y"_a);
        cls.def(
                "fillEvaluation",
                [](BasisEvaluator &self, Array1d const &array, double x, double y, Array1d const &dx,
                   Array1d const &dy) { return self.fillEvaluation(array, x, y, dx, dy); },
                "array"_a, "x"_a, "y"_a, "dx"_a, "dy"_a);
        cls.def("fillEvaluation",
                              [](BasisEvaluator &self, Array1d const &array, geom::Point2D const &point) {
                                  return self.fillEvaluation(array, point);
                              },
                              "array"_a, "point"_a);
        cls.def(
                "fillEvaluation",
                [](BasisEvaluator &self, Array1d const &array, geom::Point2D const &point, Array1d const &dx,
                   Array1d const &dy) { return self.fillEvaluation(array, point, dx, dy); },
                "array"_a, "point"_a, "dx"_a, "dy"_a);
        cls.def("fillEvaluation",
                              [](BasisEvaluator &self, Array1d const &array, geom::Extent2D const &extent) {
                                  return self.fillEvaluation(array, extent);
                              },
                              "array"_a, "extent"_a);
        cls.def(
                "fillEvaluation",
                [](BasisEvaluator &self, Array1d const &array, geom::Extent2D const &extent,
                   Array1d const &dx, Array1d const &dy) { return self.fillEvaluation(array, extent, dx, dy); },
                "array"_a, "extent"_a, "dx"_a, "dy"_a);
        cls.def("fillIntegration", &BasisEvaluator::fillIntegration, "array"_a, "xMoment"_a = 0,
                              "yMoment"_a = 0);
    });
}

wrapConstants()

void lsst::shapelet::wrapConstants

(

WrapperCollection &

wrappers

)

Definition at line 33 of file constants.cc.

                                                                  {
 
    wrappers.wrapType(py::enum_<BasisTypeEnum>(wrappers.module, "BasisTypeEnum"), [](auto &mod, auto &enm) {
        enm.value("HERMITE", BasisTypeEnum::HERMITE);
        enm.value("LAGUERRE", BasisTypeEnum::LAGUERRE);
        enm.export_values();
 
        mod.def("computeOffset", computeOffset);
        mod.def("computeSize", computeSize);
        mod.def("computeOrder", computeOrder);
        mod.def("intSqrt", intSqrt);
        mod.def("rationalSqrt", rationalSqrt);
    });
}

wrapFunctorKeys()

void lsst::shapelet::wrapFunctorKeys

(

WrapperCollection &

wrappers

)

Definition at line 35 of file functorKeys.cc.

                                                                    {
    using PyShapeletFunctionKey = py::class_<ShapeletFunctionKey, std::shared_ptr<ShapeletFunctionKey>>;
 
    wrappers.wrapType(PyShapeletFunctionKey(wrappers.module, "ShapeletFunctionKey"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        cls.def(
                py::init<afw::table::EllipseKey const &, afw::table::ArrayKey<double> const &, BasisTypeEnum>(),
                "ellipse"_a, "coefficients"_a, "basisType"_a = HERMITE);
        cls.def(py::init<afw::table::SubSchema const &, BasisTypeEnum>(), "s"_a,
                "basisType"_a = HERMITE);
 
        cls.def("__eq__", &ShapeletFunctionKey::operator==, py::is_operator());
        cls.def("__ne__", &ShapeletFunctionKey::operator!=, py::is_operator());
 
        cls.def_static("addFields", &ShapeletFunctionKey::addFields, "schema"_a, "name"_a,
                       "doc"_a, "ellipseUnit"_a, "coeffUnit"_a, "order"_a,
                       "basisType"_a = HERMITE);
 
        cls.def("get", &ShapeletFunctionKey::get);
        cls.def("set", &ShapeletFunctionKey::set);
        cls.def("isValid", &ShapeletFunctionKey::isValid);
        cls.def("getEllipse", &ShapeletFunctionKey::getEllipse);
        cls.def("getCoefficients", &ShapeletFunctionKey::getCoefficients);
        cls.def("getOrder", &ShapeletFunctionKey::getOrder);
        cls.def("getBasisType", &ShapeletFunctionKey::getBasisType);
    });
 
    using PyMultiShapeletFunctionKey = py::class_<MultiShapeletFunctionKey, std::shared_ptr<MultiShapeletFunctionKey>>;
 
    wrappers.wrapType(PyMultiShapeletFunctionKey(wrappers.module, "MultiShapeletFunctionKey"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        cls.def(py::init<afw::table::SubSchema const &, BasisTypeEnum>(), "s"_a,
                                        "basisType"_a = HERMITE);
        cls.def(py::init<std::vector<std::shared_ptr<ShapeletFunctionKey>> const &>(),
                                        "components"_a);
 
        cls.def_static("addFields", MultiShapeletFunctionKey::addFields, "schema"_a,
                                               "name"_a, "doc"_a, "ellipseUnit"_a, "coeffUnit"_a, "orders"_a,
                                               "basisType"_a = HERMITE);
 
        cls.def("__eq__", &MultiShapeletFunctionKey::operator==, py::is_operator());
        cls.def("__ne__", &MultiShapeletFunctionKey::operator!=, py::is_operator());
        cls.def("__getitem__",
                                        [](MultiShapeletFunctionKey &self, int i) { return self[i]; });
 
        cls.def("get", &MultiShapeletFunctionKey::get);
        cls.def("set", &MultiShapeletFunctionKey::set);
        cls.def("isValid", &MultiShapeletFunctionKey::isValid);
    });
}

wrapGaussHermiteConvolution()

void lsst::shapelet::wrapGaussHermiteConvolution

(

WrapperCollection &

wrappers

)

Definition at line 36 of file gaussHermiteConvolution.cc.

                                                                                {
    using PyGaussHermiteConvolution = py::class_<GaussHermiteConvolution, std::shared_ptr<GaussHermiteConvolution>>;
    wrappers.wrapType(PyGaussHermiteConvolution(wrappers.module, "GaussHermiteConvolution"), [](auto &mod, auto &cls) {
        cls.def(py::init<int, ShapeletFunction const &>(), "colOrder"_a, "psf"_a);
 
        cls.def("computeRowOrder", &GaussHermiteConvolution::computeRowOrder);
        cls.def("evaluate", &GaussHermiteConvolution::evaluate);
        cls.def("getColOrder", &GaussHermiteConvolution::getColOrder);
        cls.def("getRowOrder", &GaussHermiteConvolution::getRowOrder);
    });
}

wrapGaussHermiteProjection()

void lsst::shapelet::wrapGaussHermiteProjection

(

WrapperCollection &

wrappers

)

Definition at line 34 of file gaussHermiteProjection.cc.

                                                                               {
    using PyGaussHermiteProjection = py::class_<GaussHermiteProjection, std::shared_ptr<GaussHermiteProjection>>;
 
    wrappers.wrapType(PyGaussHermiteProjection(wrappers.module, "GaussHermiteProjection"), [](auto &mod, auto &cls) {
        cls.def(py::init<int>(), "maxOrder"_a);
 
        cls.def("compute",
                                      (Eigen::MatrixXd (GaussHermiteProjection::*)(
                                              afw::geom::ellipses::Quadrupole const &, int inputOrder,
                                              afw::geom::ellipses::Quadrupole const &, int outputOrder) const) &
                                              GaussHermiteProjection::compute);
        cls.def("compute",
                                      (Eigen::MatrixXd (GaussHermiteProjection::*)(
                                              geom::LinearTransform const &, int inputOrder,
                                              geom::LinearTransform const &, int outputOrder) const) &
                                              GaussHermiteProjection::compute);
        cls.def(
                "compute", (Eigen::MatrixXd (GaussHermiteProjection::*)(Eigen::Matrix2d const &, int,
                                                                        Eigen::Matrix2d const &, int) const) &
                        GaussHermiteProjection::compute);
 
        cls.def("getMaxOrder", &GaussHermiteProjection::getMaxOrder);
    });
}

wrapHermiteTransformMatrix()

void lsst::shapelet::wrapHermiteTransformMatrix

(

WrapperCollection &

wrappers

)

Definition at line 34 of file hermiteTransformMatrix.cc.

                                                                               {
    using PyHermiteTransformMatrix = py::class_<HermiteTransformMatrix, std::shared_ptr<HermiteTransformMatrix>>;
 
    wrappers.wrapType(PyHermiteTransformMatrix(wrappers.module, "HermiteTransformMatrix"), [](auto &mod, auto &cls) {
        cls.def(py::init<int>(), "order"_a);
 
        cls.def(
                "compute", (Eigen::MatrixXd (HermiteTransformMatrix::*)(Eigen::Matrix2d const &) const) &
                        HermiteTransformMatrix::compute,
                "transform"_a);
        cls.def(
                "compute",
                (Eigen::MatrixXd (HermiteTransformMatrix::*)(geom::LinearTransform const &) const) &
                        HermiteTransformMatrix::compute,
                "transform"_a);
        cls.def(
                "compute", (Eigen::MatrixXd (HermiteTransformMatrix::*)(Eigen::Matrix2d const &, int) const) &
                        HermiteTransformMatrix::compute,
                "transform"_a, "order"_a);
        cls.def("compute", (Eigen::MatrixXd (HermiteTransformMatrix::*)(
                                              geom::LinearTransform const &, int) const) &
                                              HermiteTransformMatrix::compute,
                                      "transform"_a, "order"_a);
 
        cls.def("getCoefficientMatrix", &HermiteTransformMatrix::getCoefficientMatrix);
        cls.def("getInverseCoefficientMatrix",
                                      &HermiteTransformMatrix::getInverseCoefficientMatrix);
        cls.def("getOrder", &HermiteTransformMatrix::getOrder);
    });
}

wrapMatrixBuilder()

void lsst::shapelet::wrapMatrixBuilder

(

WrapperCollection &

wrappers

)

Definition at line 132 of file matrixBuilder.cc.

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

wrapMultiShapeletBasis()

void lsst::shapelet::wrapMultiShapeletBasis

(

WrapperCollection &

wrappers

)

Definition at line 35 of file multiShapeletBasis.cc.

                                                                           {
    using PyClass = py::class_<MultiShapeletBasisComponent, std::shared_ptr<MultiShapeletBasisComponent>>;
 
    static auto component =
            wrappers.wrapType(PyClass(wrappers.module, "MultiShapeletBasisComponent"), [](auto &mod, auto &cls) {
                cls.def(py::init<double, int, ndarray::Array<double const, 2, 2> const &>(),
                        "radius"_a, "order"_a, "matrix"_a);
 
                cls.def("getRadius", &MultiShapeletBasisComponent::getRadius);
                cls.def("getOrder", &MultiShapeletBasisComponent::getOrder);
                cls.def("getMatrix", &MultiShapeletBasisComponent::getMatrix);
            });
 
    using PyMultiShapeletBasis = py::class_<MultiShapeletBasis, std::shared_ptr<MultiShapeletBasis>>;
 
    wrappers.wrapType(PyMultiShapeletBasis(wrappers.module, "MultiShapeletBasis"), [](auto &mod, auto &cls) {
        cls.attr("Component") = component;
 
        cls.def(py::init<int>());
        cls.def(py::init<MultiShapeletBasis const &>());
 
        cls.def("getSize", &MultiShapeletBasis::getSize);
        cls.def("getComponentCount", &MultiShapeletBasis::getComponentCount);
        cls.def("addComponent", &MultiShapeletBasis::addComponent);
        cls.def("scale", &MultiShapeletBasis::scale);
        cls.def("normalize", &MultiShapeletBasis::normalize);
        cls.def("merge", &MultiShapeletBasis::merge);
        cls.def("makeFunction", &MultiShapeletBasis::makeFunction);
    });
}

wrapMultiShapeletFunction()

void lsst::shapelet::wrapMultiShapeletFunction

(

WrapperCollection &

wrappers

)

Definition at line 95 of file multiShapeletFunction.cc.

                                                                              {
    using PyMultiShapeletFunction = py::class_<MultiShapeletFunction, std::shared_ptr<MultiShapeletFunction>>;
 
    wrappers.wrapType(PyMultiShapeletFunction(wrappers.module, "MultiShapeletFunction"), [](auto &mod, auto &cls) {
        declareMultiShapeletFunctionMembers(cls);
 
    });
 
    using PyMultiShapeletFunctionEvaluator =
            py::class_<MultiShapeletFunctionEvaluator, std::shared_ptr<MultiShapeletFunctionEvaluator>>;
 
    wrappers.wrapType(PyMultiShapeletFunctionEvaluator(wrappers.module, "MultiShapeletFunctionEvaluator"), [](auto &mod, auto &cls) {
        declareMultiShapeletFunctionEvaluatorMembers(cls);
    });
}

wrapRadialProfile()

void lsst::shapelet::wrapRadialProfile

(

WrapperCollection &

wrappers

)

Definition at line 35 of file radialProfile.cc.

                                                                      {
    using PyRadialProfil = py::class_<RadialProfile, std::shared_ptr<RadialProfile>> ;
    wrappers.wrapType(PyRadialProfil(wrappers.module, "RadialProfile"), [](auto &mod, auto &cls) {
        cls.def_static("get", &RadialProfile::get, py::return_value_policy::reference);
        cls.def("getName", &RadialProfile::getName);
        cls.def("_evaluate", (double (RadialProfile::*)(double) const) &RadialProfile::evaluate);
        cls.def("_evaluate", (ndarray::Array<double, 1, 1> (RadialProfile::*)(
                ndarray::Array<double const, 1, 1> const &) const) &
                RadialProfile::evaluate);
        cls.def("getMomentsRadiusFactor", &RadialProfile::getMomentsRadiusFactor);
        cls.def("getBasis", &RadialProfile::getBasis, "nComponents"_a, "maxRadius"_a = 0);
        cls.def("registerBasis", &RadialProfile::registerBasis);
    });
}

wrapShapeletFunction()

void lsst::shapelet::wrapShapeletFunction

(

WrapperCollection &

wrappers

)

Definition at line 35 of file shapeletFunction.cc.

                                                                         {
    using PyShapeletFunction = py::class_<ShapeletFunction, std::shared_ptr<ShapeletFunction>>;
 
    wrappers.wrapType(PyShapeletFunction(wrappers.module, "ShapeletFunction"), [](auto &mod, auto &cls) {
        cls.def_readonly_static("FLUX_FACTOR", &ShapeletFunction::FLUX_FACTOR);
 
        cls.def(py::init<int, BasisTypeEnum>(), "order"_a, "basisType"_a);
        cls.def(py::init<int, BasisTypeEnum, ndarray::Array<double, 1, 1> const &>(), "order"_a,
                                "basisType"_a, "coefficients"_a);
        cls.def(py::init<int, BasisTypeEnum, double, geom::Point2D const &>(), "order"_a,
                                "basisType"_a, "radius"_a, "center"_a = geom::Point2D());
        cls.def(py::init<int, BasisTypeEnum, double, geom::Point2D const &,
                                        ndarray::Array<double, 1, 1> const &>(),
                                "order"_a, "basisType"_a, "radius"_a, "center"_a, "coefficients"_a);
        cls.def(py::init<int, BasisTypeEnum, afw::geom::ellipses::Ellipse const &>(), "order"_a,
                                "basisType"_a, "ellipse"_a);
        cls.def(py::init<int, BasisTypeEnum, afw::geom::ellipses::Ellipse const &,
                                        ndarray::Array<double const, 1, 1> const &>(),
                                "order"_a, "basisType"_a, "ellipse"_a, "coefficients"_a);
        cls.def(py::init<ShapeletFunction>());
 
        cls.def("getOrder", &ShapeletFunction::getOrder);
        cls.def("getEllipse", (afw::geom::ellipses::Ellipse &(ShapeletFunction::*)()) &
                                        ShapeletFunction::getEllipse,
                                py::return_value_policy::reference_internal);
        cls.def("setEllipse", &ShapeletFunction::setEllipse);
        cls.def("getBasisType", &ShapeletFunction::getBasisType);
        cls.def("changeBasisType", &ShapeletFunction::changeBasisType);
        cls.def("normalize", &ShapeletFunction::normalize, "value"_a = 1.0);
        cls.def("getCoefficients", (ndarray::Array<double, 1, 1> const (ShapeletFunction::*)()) &
                ShapeletFunction::getCoefficients);
        cls.def("convolve", &ShapeletFunction::convolve);
        cls.def("evaluate", &ShapeletFunction::evaluate);
        cls.def("shiftInPlace", &ShapeletFunction::shiftInPlace);
        cls.def("transformInPlace", &ShapeletFunction::transformInPlace);
    });
 
    using PyShapeletFunctionEvaluator =
            py::class_<ShapeletFunctionEvaluator, std::shared_ptr<ShapeletFunctionEvaluator>>;
 
    wrappers.wrapType(
            PyShapeletFunctionEvaluator(wrappers.module, "ShapeletFunctionEvaluator"), [](auto &mod, auto &cls) {
                cls.def(py::init<ShapeletFunction const &>(), "function"_a);
 
                cls.def("__call__",
                        (double (ShapeletFunctionEvaluator::*)(double, double) const) &
                                ShapeletFunctionEvaluator::operator());
                cls.def(
                        "__call__", (double (ShapeletFunctionEvaluator::*)(geom::Point2D const &) const) &
                                ShapeletFunctionEvaluator::operator());
                cls.def(
                        "__call__", (double (ShapeletFunctionEvaluator::*)(geom::Extent2D const &) const) &
                                ShapeletFunctionEvaluator::operator());
                cls.def("__call__", (ndarray::Array<double, 1, 1> (ShapeletFunctionEvaluator::*)(
                        ndarray::Array<double const, 1> const &,
                        ndarray::Array<double const, 1> const &) const) &
                        ShapeletFunctionEvaluator::operator());
 
                cls.def(
                        "addToImage", (void (ShapeletFunctionEvaluator::*)(ndarray::Array<double, 2, 1> const &,
                                                                           geom::Point2I const &) const) &
                                ShapeletFunctionEvaluator::addToImage,
                        "array"_a, "xy0"_a = geom::Point2D());
                cls.def(
                        "addToImage", (void (ShapeletFunctionEvaluator::*)(afw::image::Image<double> &) const) &
                                ShapeletFunctionEvaluator::addToImage,
                        "image"_a);
                cls.def("integrate", &ShapeletFunctionEvaluator::integrate);
                cls.def("computeMoments", &ShapeletFunctionEvaluator::computeMoments);
                cls.def("update", &ShapeletFunctionEvaluator::update);
            });
}

Variable Documentation

BASIS_NORMALIZATION

double const lsst::shapelet::BASIS_NORMALIZATION

extern

Normalization factor for 1-d orthonormal shapelets: pi^(-1/4)