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. More...

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. More...
int	computeSize (int order)
	Return the size of the coefficient vector for the given order. More...
int	computeOrder (int size)
	Infer the order of a shapelet expansion from the number of coefficients. More...
double	intSqrt (int n)
	Compute the square root of an integer number. More...
double	rationalSqrt (int n, int d)
	Compute the square root of a rational number i.e. sqrt(n/d) More...
	PYBIND11_MODULE (basisEvaluator, mod)
	PYBIND11_MODULE (constants, mod)
	PYBIND11_MODULE (functorKeys, mod)
	PYBIND11_MODULE (gaussHermiteConvolution, mod)
	PYBIND11_MODULE (gaussHermiteProjection, mod)
	PYBIND11_MODULE (hermiteTransformMatrix, mod)
	PYBIND11_MODULE (matrixBuilder, mod)
	PYBIND11_MODULE (multiShapeletBasis, mod)
	PYBIND11_MODULE (multiShapeletFunction, mod)
	PYBIND11_MODULE (radialProfile, mod)
	PYBIND11_MODULE (shapeletFunction, mod)

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

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() [1/11]

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

Definition at line 34 of file basisEvaluator.cc.

                                     {
    py::module::import("lsst.afw.geom");
 
    py::class_<BasisEvaluator, std::shared_ptr<BasisEvaluator>> clsBasisEvaluator(mod, "BasisEvaluator");
 
    /* Constructors */
    clsBasisEvaluator.def(py::init<int, BasisTypeEnum>(), "order"_a, "basisType"_a);
 
    /* Members */
    clsBasisEvaluator.def("getOrder", &BasisEvaluator::getOrder);
    clsBasisEvaluator.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. */
    clsBasisEvaluator.def("fillEvaluation", [](BasisEvaluator &self, Array1d const &array, double x,
                                               double y) { return self.fillEvaluation(array, x, y); },
                          "array"_a, "x"_a, "y"_a);
    clsBasisEvaluator.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);
    clsBasisEvaluator.def("fillEvaluation",
                          [](BasisEvaluator &self, Array1d const &array, geom::Point2D const &point) {
                              return self.fillEvaluation(array, point);
                          },
                          "array"_a, "point"_a);
    clsBasisEvaluator.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);
    clsBasisEvaluator.def("fillEvaluation",
                          [](BasisEvaluator &self, Array1d const &array, geom::Extent2D const &extent) {
                              return self.fillEvaluation(array, extent);
                          },
                          "array"_a, "extent"_a);
    clsBasisEvaluator.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);
    clsBasisEvaluator.def("fillIntegration", &BasisEvaluator::fillIntegration, "array"_a, "xMoment"_a = 0,
                          "yMoment"_a = 0);
}

PYBIND11_MODULE() [2/11]

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

Definition at line 32 of file constants.cc.

                                {
    py::enum_<BasisTypeEnum>(mod, "BasisTypeEnum")
        .value("HERMITE", BasisTypeEnum::HERMITE)
        .value("LAGUERRE", BasisTypeEnum::LAGUERRE)
        .export_values();
 
    mod.def("computeOffset", computeOffset);
    mod.def("computeSize", computeSize);
    mod.def("computeOrder", computeOrder);
    mod.def("intSqrt", intSqrt);
    mod.def("rationalSqrt", rationalSqrt);
}

PYBIND11_MODULE() [3/11]

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

Definition at line 34 of file functorKeys.cc.

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

PYBIND11_MODULE() [4/11]

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

Definition at line 35 of file gaussHermiteConvolution.cc.

                                              {
    py::class_<GaussHermiteConvolution, std::shared_ptr<GaussHermiteConvolution>> clsGaussHermiteConvolution(
        mod, "GaussHermiteConvolution");
 
    clsGaussHermiteConvolution.def(py::init<int, ShapeletFunction const &>(), "colOrder"_a, "psf"_a);
 
    clsGaussHermiteConvolution.def("computeRowOrder", &GaussHermiteConvolution::computeRowOrder);
    clsGaussHermiteConvolution.def("evaluate", &GaussHermiteConvolution::evaluate);
    clsGaussHermiteConvolution.def("getColOrder", &GaussHermiteConvolution::getColOrder);
    clsGaussHermiteConvolution.def("getRowOrder", &GaussHermiteConvolution::getRowOrder);
}

PYBIND11_MODULE() [5/11]

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

Definition at line 34 of file gaussHermiteProjection.cc.

                                             {
    py::module::import("lsst.afw.geom");
        py::class_<GaussHermiteProjection, std::shared_ptr<GaussHermiteProjection>> clsGaussHermiteProjection(
            mod, "GaussHermiteProjection");
 
    clsGaussHermiteProjection.def(py::init<int>(), "maxOrder"_a);
 
    clsGaussHermiteProjection.def("compute",
                                  (Eigen::MatrixXd (GaussHermiteProjection::*)(
                                          afw::geom::ellipses::Quadrupole const &, int inputOrder,
                                          afw::geom::ellipses::Quadrupole const &, int outputOrder) const) &
                                          GaussHermiteProjection::compute);
    clsGaussHermiteProjection.def("compute",
                                  (Eigen::MatrixXd (GaussHermiteProjection::*)(
                                          geom::LinearTransform const &, int inputOrder,
                                          geom::LinearTransform const &, int outputOrder) const) &
                                          GaussHermiteProjection::compute);
    clsGaussHermiteProjection.def(
            "compute", (Eigen::MatrixXd (GaussHermiteProjection::*)(Eigen::Matrix2d const &, int,
                                                                    Eigen::Matrix2d const &, int) const) &
                               GaussHermiteProjection::compute);
 
    clsGaussHermiteProjection.def("getMaxOrder", &GaussHermiteProjection::getMaxOrder);
}

PYBIND11_MODULE() [6/11]

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

Definition at line 34 of file hermiteTransformMatrix.cc.

                                             {
    py::module::import("lsst.afw.geom");
 
    py::class_<HermiteTransformMatrix, std::shared_ptr<HermiteTransformMatrix>> clsHermiteTransformMatrix(
        mod, "HermiteTransformMatrix");
 
    clsHermiteTransformMatrix.def(py::init<int>(), "order"_a);
 
    clsHermiteTransformMatrix.def(
            "compute", (Eigen::MatrixXd (HermiteTransformMatrix::*)(Eigen::Matrix2d const &) const) &
                               HermiteTransformMatrix::compute,
            "transform"_a);
    clsHermiteTransformMatrix.def(
            "compute",
            (Eigen::MatrixXd (HermiteTransformMatrix::*)(geom::LinearTransform const &) const) &
                    HermiteTransformMatrix::compute,
            "transform"_a);
    clsHermiteTransformMatrix.def(
            "compute", (Eigen::MatrixXd (HermiteTransformMatrix::*)(Eigen::Matrix2d const &, int) const) &
                               HermiteTransformMatrix::compute,
            "transform"_a, "order"_a);
    clsHermiteTransformMatrix.def("compute", (Eigen::MatrixXd (HermiteTransformMatrix::*)(
                                                     geom::LinearTransform const &, int) const) &
                                                     HermiteTransformMatrix::compute,
                                  "transform"_a, "order"_a);
 
    clsHermiteTransformMatrix.def("getCoefficientMatrix", &HermiteTransformMatrix::getCoefficientMatrix);
    clsHermiteTransformMatrix.def("getInverseCoefficientMatrix",
                                  &HermiteTransformMatrix::getInverseCoefficientMatrix);
    clsHermiteTransformMatrix.def("getOrder", &HermiteTransformMatrix::getOrder);
}

PYBIND11_MODULE() [7/11]

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

Definition at line 129 of file matrixBuilder.cc.

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

PYBIND11_MODULE() [8/11]

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

Definition at line 34 of file multiShapeletBasis.cc.

                                         {
    py::class_<MultiShapeletBasisComponent, std::shared_ptr<MultiShapeletBasisComponent>>
        clsMultiShapeletBasisComponent(mod, "MultiShapeletBasisComponent");
 
    clsMultiShapeletBasisComponent.def(py::init<double, int, ndarray::Array<double const, 2, 2> const &>(),
                                       "radius"_a, "order"_a, "matrix"_a);
 
    clsMultiShapeletBasisComponent.def("getRadius", &MultiShapeletBasisComponent::getRadius);
    clsMultiShapeletBasisComponent.def("getOrder", &MultiShapeletBasisComponent::getOrder);
    clsMultiShapeletBasisComponent.def("getMatrix", &MultiShapeletBasisComponent::getMatrix);
 
    py::class_<MultiShapeletBasis, std::shared_ptr<MultiShapeletBasis>> clsMultiShapeletBasis(
            mod, "MultiShapeletBasis");
 
    clsMultiShapeletBasis.attr("Component") = clsMultiShapeletBasisComponent;
 
    clsMultiShapeletBasis.def(py::init<int>());
    clsMultiShapeletBasis.def(py::init<MultiShapeletBasis const &>());
 
    clsMultiShapeletBasis.def("getSize", &MultiShapeletBasis::getSize);
    clsMultiShapeletBasis.def("getComponentCount", &MultiShapeletBasis::getComponentCount);
    clsMultiShapeletBasis.def("addComponent", &MultiShapeletBasis::addComponent);
    clsMultiShapeletBasis.def("scale", &MultiShapeletBasis::scale);
    clsMultiShapeletBasis.def("normalize", &MultiShapeletBasis::normalize);
    clsMultiShapeletBasis.def("merge", &MultiShapeletBasis::merge);
    clsMultiShapeletBasis.def("makeFunction", &MultiShapeletBasis::makeFunction);
}

PYBIND11_MODULE() [9/11]

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

Definition at line 94 of file multiShapeletFunction.cc.

                                            {
    py::module::import("lsst.afw.geom");
    py::module::import("lsst.afw.image");
 
        py::class_<MultiShapeletFunction, std::shared_ptr<MultiShapeletFunction>> clsMultiShapeletFunction(
            mod, "MultiShapeletFunction");
    py::class_<MultiShapeletFunctionEvaluator, std::shared_ptr<MultiShapeletFunctionEvaluator>>
            clsMultiShapeletFunctionEvaluator(mod, "MultiShapeletFunctionEvaluator");
 
    declareMultiShapeletFunctionMembers(clsMultiShapeletFunction);
    declareMultiShapeletFunctionEvaluatorMembers(clsMultiShapeletFunctionEvaluator);
}

PYBIND11_MODULE() [10/11]

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

Definition at line 34 of file radialProfile.cc.

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

PYBIND11_MODULE() [11/11]

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

Definition at line 34 of file shapeletFunction.cc.

                                       {
    py::module::import("lsst.geom");
    py::module::import("lsst.afw.geom");
    py::module::import("lsst.afw.image");
 
    py::class_<ShapeletFunction, std::shared_ptr<ShapeletFunction>> clsShapeletFunction(mod,
                                                                                        "ShapeletFunction");
 
    clsShapeletFunction.def_readonly_static("FLUX_FACTOR", &ShapeletFunction::FLUX_FACTOR);
 
    clsShapeletFunction.def(py::init<int, BasisTypeEnum>(), "order"_a, "basisType"_a);
    clsShapeletFunction.def(py::init<int, BasisTypeEnum, ndarray::Array<double, 1, 1> const &>(), "order"_a,
                            "basisType"_a, "coefficients"_a);
    clsShapeletFunction.def(py::init<int, BasisTypeEnum, double, geom::Point2D const &>(), "order"_a,
                            "basisType"_a, "radius"_a, "center"_a = geom::Point2D());
    clsShapeletFunction.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);
    clsShapeletFunction.def(py::init<int, BasisTypeEnum, afw::geom::ellipses::Ellipse const &>(), "order"_a,
                            "basisType"_a, "ellipse"_a);
    clsShapeletFunction.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);
    clsShapeletFunction.def(py::init<ShapeletFunction>());
 
    clsShapeletFunction.def("getOrder", &ShapeletFunction::getOrder);
    clsShapeletFunction.def("getEllipse", (afw::geom::ellipses::Ellipse & (ShapeletFunction::*)()) &
                                                  ShapeletFunction::getEllipse,
                            py::return_value_policy::reference_internal);
    clsShapeletFunction.def("setEllipse", &ShapeletFunction::setEllipse);
    clsShapeletFunction.def("getBasisType", &ShapeletFunction::getBasisType);
    clsShapeletFunction.def("changeBasisType", &ShapeletFunction::changeBasisType);
    clsShapeletFunction.def("normalize", &ShapeletFunction::normalize, "value"_a = 1.0);
    clsShapeletFunction.def("getCoefficients", (ndarray::Array<double, 1, 1> const (ShapeletFunction::*)()) &
                                                       ShapeletFunction::getCoefficients);
    clsShapeletFunction.def("convolve", &ShapeletFunction::convolve);
    clsShapeletFunction.def("evaluate", &ShapeletFunction::evaluate);
    clsShapeletFunction.def("shiftInPlace", &ShapeletFunction::shiftInPlace);
    clsShapeletFunction.def("transformInPlace", &ShapeletFunction::transformInPlace);
 
    py::class_<ShapeletFunctionEvaluator, std::shared_ptr<ShapeletFunctionEvaluator>>
            clsShapeletFunctionEvaluator(mod, "ShapeletFunctionEvaluator");
 
    clsShapeletFunctionEvaluator.def(py::init<ShapeletFunction const &>(), "function"_a);
 
    clsShapeletFunctionEvaluator.def("__call__",
                                     (double (ShapeletFunctionEvaluator::*)(double, double) const) &
                                             ShapeletFunctionEvaluator::operator());
    clsShapeletFunctionEvaluator.def(
            "__call__", (double (ShapeletFunctionEvaluator::*)(geom::Point2D const &) const) &
                                ShapeletFunctionEvaluator::operator());
    clsShapeletFunctionEvaluator.def(
            "__call__", (double (ShapeletFunctionEvaluator::*)(geom::Extent2D const &) const) &
                                ShapeletFunctionEvaluator::operator());
    clsShapeletFunctionEvaluator.def("__call__", (ndarray::Array<double, 1, 1> (ShapeletFunctionEvaluator::*)(
                                                         ndarray::Array<double const, 1> const &,
                                                         ndarray::Array<double const, 1> const &) const) &
                                                         ShapeletFunctionEvaluator::operator());
 
    clsShapeletFunctionEvaluator.def(
            "addToImage", (void (ShapeletFunctionEvaluator::*)(ndarray::Array<double, 2, 1> const &,
                                                               geom::Point2I const &) const) &
                                  ShapeletFunctionEvaluator::addToImage,
            "array"_a, "xy0"_a = geom::Point2D());
    clsShapeletFunctionEvaluator.def(
            "addToImage", (void (ShapeletFunctionEvaluator::*)(afw::image::Image<double> &) const) &
                                  ShapeletFunctionEvaluator::addToImage,
            "image"_a);
    clsShapeletFunctionEvaluator.def("integrate", &ShapeletFunctionEvaluator::integrate);
    clsShapeletFunctionEvaluator.def("computeMoments", &ShapeletFunctionEvaluator::computeMoments);
    clsShapeletFunctionEvaluator.def("update", &ShapeletFunctionEvaluator::update);
}

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

Variable Documentation

BASIS_NORMALIZATION

double const lsst::shapelet::BASIS_NORMALIZATION

extern

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