chebyshevBoundedField.cc File Reference

#include <pybind11/pybind11.h>
#include <pybind11/operators.h>
#include <pybind11/stl.h>
#include "ndarray/pybind11.h"
#include "lsst/pex/config/python.h"
#include "lsst/afw/table/io/python.h"
#include "lsst/afw/table/io/Persistable.h"
#include "lsst/afw/math/BoundedField.h"
#include "lsst/afw/math/ChebyshevBoundedField.h"

Go to the source code of this file.

Typedefs
using	ClsField = py::class_< ChebyshevBoundedField, std::shared_ptr< ChebyshevBoundedField >, BoundedField >

Functions
template<typename PixelT >
void	declareTemplates (ClsField &cls)
	PYBIND11_MODULE (chebyshevBoundedField, mod)

Typedef Documentation

ClsField

using ClsField = py::class_<ChebyshevBoundedField, std::shared_ptr<ChebyshevBoundedField>, BoundedField>

Definition at line 40 of file chebyshevBoundedField.cc.

Function Documentation

declareTemplates()

template<typename PixelT >

void declareTemplates

(

ClsField &

cls

)

Definition at line 44 of file chebyshevBoundedField.cc.

                                      {
    cls.def_static("fit", (std::shared_ptr<ChebyshevBoundedField>(*)(lsst::afw::image::Image<PixelT> const &,
                                                                     ChebyshevBoundedFieldControl const &)) &
                                  ChebyshevBoundedField::fit);
}

PYBIND11_MODULE()

PYBIND11_MODULE	(	chebyshevBoundedField	,
		mod
	)

Definition at line 50 of file chebyshevBoundedField.cc.

                                            {
    /* Module level */
    py::class_<ChebyshevBoundedFieldControl> clsChebyshevBoundedFieldControl(mod,
                                                                             "ChebyshevBoundedFieldControl");
    ClsField clsChebyshevBoundedField(mod, "ChebyshevBoundedField");
 
    /* Member types and enums */
    using Control = ChebyshevBoundedFieldControl;
 
    /* Constructors */
    clsChebyshevBoundedFieldControl.def(py::init<>());
    clsChebyshevBoundedField.def(
            py::init<lsst::geom::Box2I const &, ndarray::Array<double const, 2, 2> const &>());
 
    /* Operators are defined only in the BoundedField base class;
       we let Python inheritance provide them here. */
 
    /* Members */
    LSST_DECLARE_CONTROL_FIELD(clsChebyshevBoundedFieldControl, ChebyshevBoundedFieldControl, orderX);
    LSST_DECLARE_CONTROL_FIELD(clsChebyshevBoundedFieldControl, ChebyshevBoundedFieldControl, orderY);
    LSST_DECLARE_CONTROL_FIELD(clsChebyshevBoundedFieldControl, ChebyshevBoundedFieldControl, triangular);
 
    clsChebyshevBoundedFieldControl.def("computeSize", &ChebyshevBoundedFieldControl::computeSize);
 
    clsChebyshevBoundedField.def("getCoefficients", &ChebyshevBoundedField::getCoefficients);
    clsChebyshevBoundedField.def_static(
            "fit", (std::shared_ptr<ChebyshevBoundedField>(*)(
                           lsst::geom::Box2I const &, ndarray::Array<double const, 1> const &,
                           ndarray::Array<double const, 1> const &, ndarray::Array<double const, 1> const &,
                           Control const &)) &
                           ChebyshevBoundedField::fit);
    clsChebyshevBoundedField.def_static(
            "fit", (std::shared_ptr<ChebyshevBoundedField>(*)(
                           lsst::geom::Box2I const &, ndarray::Array<double const, 1> const &,
                           ndarray::Array<double const, 1> const &, ndarray::Array<double const, 1> const &,
                           ndarray::Array<double const, 1> const &, Control const &)) &
                           ChebyshevBoundedField::fit);
 
    clsChebyshevBoundedField.def("truncate", &ChebyshevBoundedField::truncate);
 
    // Pybind11 resolves overloads by picking the first one that might work
    declareTemplates<double>(clsChebyshevBoundedField);
    declareTemplates<float>(clsChebyshevBoundedField);
}