lsst::afw::geom::ellipses Namespace Reference

Namespaces
namespace	_axes
namespace	_ellipse
namespace	_quadrupole
namespace	detail

Classes
class	Axes
	An ellipse core for the semimajor/semiminor axis and position angle parametrization (a,b,theta). More...
class	BaseCore
	A base class for parametrizations of the "core" of an ellipse - the ellipticity and size. More...
class	ConformalShear
	A logarithmic complex ellipticity with magnitude \(|e| = \ln (a/b) \). More...
class	DeterminantRadius
	The radius defined as the 4th root of the determinant of the quadrupole matrix. More...
class	Distortion
	A complex ellipticity with magnitude \(|e| = \frac{a^2 - b^2}{a^2 + b^2}\). More...
class	Ellipse
	An ellipse defined by an arbitrary BaseCore and a center point. More...
class	EllipseHorizontalLineIntersection
class	EllipseMatplotlibInterface
class	LogDeterminantRadius
	The natural logarithm of the DeterminantRadius. More...
class	LogTraceRadius
	The natural logarithm of the TraceRadius. More...
class	Parametric
	A functor that returns points on the boundary of the ellipse as a function of a parameter that runs between 0 and 2 pi (but is not angle). More...
class	PixelRegion
	A pixelized region containing all pixels whose centers are within an Ellipse. More...
class	Quadrupole
	An ellipse core with quadrupole moments as parameters. More...
class	ReducedShear
	A complex ellipticity with magnitude \(|e| = \frac{a-b}{a+b} \). More...
class	Separable
	An ellipse core with a complex ellipticity and radius parameterization. More...
class	TraceRadius
	The radius defined as \(\sqrt{0.5(I_{xx} + I_{yy})}\). More...

Typedefs
using	SeparableDistortionDeterminantRadius = Separable<Distortion, DeterminantRadius>
using	SeparableDistortionTraceRadius = Separable<Distortion, TraceRadius>
using	SeparableDistortionLogDeterminantRadius = Separable<Distortion, LogDeterminantRadius>
using	SeparableDistortionLogTraceRadius = Separable<Distortion, LogTraceRadius>
using	SeparableConformalShearDeterminantRadius = Separable<ConformalShear, DeterminantRadius>
using	SeparableConformalShearTraceRadius = Separable<ConformalShear, TraceRadius>
using	SeparableConformalShearLogDeterminantRadius = Separable<ConformalShear, LogDeterminantRadius>
using	SeparableConformalShearLogTraceRadius = Separable<ConformalShear, LogTraceRadius>
using	SeparableReducedShearDeterminantRadius = Separable<ReducedShear, DeterminantRadius>
using	SeparableReducedShearTraceRadius = Separable<ReducedShear, TraceRadius>
using	SeparableReducedShearLogDeterminantRadius = Separable<ReducedShear, LogDeterminantRadius>
using	SeparableReducedShearLogTraceRadius = Separable<ReducedShear, LogTraceRadius>

Functions
	Ellipse_plot (self, axes=None, scale=1.0, show=True, rescale=True, **kwds)
void	wrapAxes (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapBaseCore (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapConformalShear (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapDistortion (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapEllipse (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapPixelRegion (lsst::cpputils::python::WrapperCollection &)
void	wrapRadii (lsst::cpputils::python::WrapperCollection &)
void	wrapEllipticityBase (lsst::cpputils::python::WrapperCollection &)
void	wrapReducedShear (lsst::cpputils::python::WrapperCollection &)
void	wrapQuadrupole (lsst::cpputils::python::WrapperCollection &)
void	wrapSeparable (lsst::cpputils::python::WrapperCollection &)
	PYBIND11_MODULE (_ellipses, mod)
template<typename Ellipticity_, typename Radius_>
void	declareSeparable (lsst::cpputils::python::WrapperCollection &wrappers, const std::string &suffix)

Variables
dict	Separable
	MatplotlibInterface
	plot
template<typename Ellipticity_, typename Radius_>
BaseCore::Registrar< Separable< Ellipticity_, Radius_ > >	Separable< Ellipticity_, Radius_ >::registrar

Detailed Description

lsst.afw.geom.ellipses

Typedef Documentation

SeparableConformalShearDeterminantRadius

using lsst::afw::geom::ellipses::SeparableConformalShearDeterminantRadius = Separable<ConformalShear, DeterminantRadius>

Definition at line 57 of file ellipses.h.

SeparableConformalShearLogDeterminantRadius

using lsst::afw::geom::ellipses::SeparableConformalShearLogDeterminantRadius = Separable<ConformalShear, LogDeterminantRadius>

Definition at line 59 of file ellipses.h.

SeparableConformalShearLogTraceRadius

using lsst::afw::geom::ellipses::SeparableConformalShearLogTraceRadius = Separable<ConformalShear, LogTraceRadius>

Definition at line 60 of file ellipses.h.

SeparableConformalShearTraceRadius

using lsst::afw::geom::ellipses::SeparableConformalShearTraceRadius = Separable<ConformalShear, TraceRadius>

Definition at line 58 of file ellipses.h.

SeparableDistortionDeterminantRadius

using lsst::afw::geom::ellipses::SeparableDistortionDeterminantRadius = Separable<Distortion, DeterminantRadius>

Definition at line 52 of file ellipses.h.

SeparableDistortionLogDeterminantRadius

using lsst::afw::geom::ellipses::SeparableDistortionLogDeterminantRadius = Separable<Distortion, LogDeterminantRadius>

Definition at line 54 of file ellipses.h.

SeparableDistortionLogTraceRadius

using lsst::afw::geom::ellipses::SeparableDistortionLogTraceRadius = Separable<Distortion, LogTraceRadius>

Definition at line 55 of file ellipses.h.

SeparableDistortionTraceRadius

using lsst::afw::geom::ellipses::SeparableDistortionTraceRadius = Separable<Distortion, TraceRadius>

Definition at line 53 of file ellipses.h.

SeparableReducedShearDeterminantRadius

using lsst::afw::geom::ellipses::SeparableReducedShearDeterminantRadius = Separable<ReducedShear, DeterminantRadius>

Definition at line 62 of file ellipses.h.

SeparableReducedShearLogDeterminantRadius

using lsst::afw::geom::ellipses::SeparableReducedShearLogDeterminantRadius = Separable<ReducedShear, LogDeterminantRadius>

Definition at line 64 of file ellipses.h.

SeparableReducedShearLogTraceRadius

using lsst::afw::geom::ellipses::SeparableReducedShearLogTraceRadius = Separable<ReducedShear, LogTraceRadius>

Definition at line 65 of file ellipses.h.

SeparableReducedShearTraceRadius

using lsst::afw::geom::ellipses::SeparableReducedShearTraceRadius = Separable<ReducedShear, TraceRadius>

Definition at line 63 of file ellipses.h.

Function Documentation

declareSeparable()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::declareSeparable	(	lsst::cpputils::python::WrapperCollection &	wrappers,
		const std::string &	suffix )

Definition at line 43 of file _separable.cc.

                                                                                              {
    using Class = Separable<Ellipticity_, Radius_>;
    wrappers.wrapType(
            py::classh<Class, BaseCore>(wrappers.module,
                                                                ("Separable" + suffix).c_str()),
            [](auto &mod, auto &cls) {
                cls.def(py::init<double, double, double, bool>(), "e1"_a = 0.0, "e2"_a = 0.0,
                        "radius"_a = Radius_(), "normalize"_a = true);
                cls.def(py::init<Class const &>());
                cls.def(py::init<BaseCore const &>());
 
                cls.def("getE1", &Class::getE1);
                cls.def("setE1", &Class::setE1);
                cls.def("getE2", &Class::getE2);
                cls.def("setE2", &Class::setE2);
                cls.def("getRadius", (Radius_ const &(Class::*)() const) & Class::getRadius);
                cls.def("setRadius", (void (Class::*)(double)) & Class::setRadius);
                cls.def("setRadius", (void (Class::*)(Radius_ const &)) & Class::setRadius);
                cls.def("getEllipticity", (Ellipticity_ const &(Class::*)() const) & Class::getEllipticity);
                cls.def("clone", &Class::clone);
                cls.def("getName", &Class::getName);
                cls.def("normalize", &Class::normalize);
                cls.def("assign", [](Class &self, Class &other) { self = other; });
                cls.def("assign", [](Class &self, BaseCore &other) { self = other; });
                cls.def("transform", [](Class &self, lsst::geom::LinearTransform const &t) {
                    return std::static_pointer_cast<Class>(self.transform(t).copy());
                });
                cls.def("transformInPlace", [](Class &self, lsst::geom::LinearTransform const &t) {
                    self.transform(t).inPlace();
                });
                cls.def("__str__", [](Class &self) {
                    return py::str("({}, {})").format(self.getEllipticity(), self.getRadius());
                });
                cls.def("__repr__", [](Class &self) {
                    return py::str("Separable({}, {})").format(self.getEllipticity(), self.getRadius());
                });
            });
}

Ellipse_plot()

lsst.afw.geom.ellipses.Ellipse_plot	(		self,
			axes = None,
			scale = 1.0,
			show = True,
			rescale = True,
		**	kwds )

Plot the ellipse in matplotlib, adding a MatplotlibInterface
object as the 'matplotlib' attribute of the ellipse.

Aside from those below, keyword arguments for the
matplotlib.patches.Patch constructor are also accepted
('facecolor', 'linestyle', etc.)

Parameters
----------
axes : `matplotlib.axes.Axes`, optional
    Axes to plot on.  Defaults to matplotlib.pyplot.gca().
scale : `float`, optional
    Scale the displayed ellipse by this factor.
show : `bool`, optional
    If True, update the figure automatically.  Set to False for batch
    processing.
rescale : `bool`, optional
    If True, rescale the axes.

Returns
-------
interface : `EllipseMatplotlibInterface`
    An object that allows the matplotlib patch to be updated when the
    ellipse modified.

Definition at line 90 of file __init__.py.

def Ellipse_plot(self, axes=None, scale=1.0, show=True, rescale=True, **kwds):
    """Plot the ellipse in matplotlib, adding a MatplotlibInterface
    object as the 'matplotlib' attribute of the ellipse.
 
    Aside from those below, keyword arguments for the
    matplotlib.patches.Patch constructor are also accepted
    ('facecolor', 'linestyle', etc.)
 
    Parameters
    ----------
    axes : `matplotlib.axes.Axes`, optional
        Axes to plot on.  Defaults to matplotlib.pyplot.gca().
    scale : `float`, optional
        Scale the displayed ellipse by this factor.
    show : `bool`, optional
        If True, update the figure automatically.  Set to False for batch
        processing.
    rescale : `bool`, optional
        If True, rescale the axes.
 
    Returns
    -------
    interface : `EllipseMatplotlibInterface`
        An object that allows the matplotlib patch to be updated when the
        ellipse modified.
    """
    import matplotlib.pyplot
    interface = self.MatplotlibInterface(self, scale, **kwds)
    if axes is None:
        axes = matplotlib.pyplot.gca()
    axes.add_patch(interface.patch)
    if rescale:
        axes.autoscale_view()
    if show:
        axes.figure.canvas.draw()
    return interface
 
 

PYBIND11_MODULE()

lsst::afw::geom::ellipses::PYBIND11_MODULE	(	_ellipses	,
		mod	)

Definition at line 43 of file _ellipses.cc.

                                {
    lsst::cpputils::python::WrapperCollection wrappers(mod, "lsst.afw.geom.ellipses");
    wrappers.addSignatureDependency("lsst.afw.geom");
    wrapEllipse(wrappers);
    wrapPixelRegion(wrappers);
    wrapBaseCore(wrappers);
    wrapAxes(wrappers);
    wrapRadii(wrappers);
    wrapEllipticityBase(wrappers);
    wrapDistortion(wrappers);
    wrapConformalShear(wrappers);
    wrapQuadrupole(wrappers);
    wrapReducedShear(wrappers);
    wrapSeparable(wrappers);
    wrappers.finish();
}

wrapAxes()

void lsst::afw::geom::ellipses::wrapAxes

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 37 of file _axes.cc.

                                                             {
    wrappers.wrapType(
            py::classh<Axes, BaseCore>(wrappers.module, "Axes"),
            [](auto &mod, auto &cls) {
                /* Constructors */
                cls.def(py::init<double, double, double, bool>(), "a"_a = 1.0, "b"_a = 1.0, "theta"_a = 0.0,
                        "normalize"_a = false);
                cls.def(py::init<Axes const &>());
                cls.def(py::init<BaseCore const &>());
 
                /* Operators */
                cls.def(
                        "__eq__", [](Axes &self, Axes &other) { return self == other; }, py::is_operator());
                cls.def(
                        "__ne__", [](Axes &self, Axes &other) { return self != other; }, py::is_operator());
 
                /* Members */
                cls.def("getA", &Axes::getA);
                cls.def("setA", &Axes::setA);
                cls.def("getB", &Axes::getB);
                cls.def("setB", &Axes::setB);
                cls.def("getTheta", &Axes::getTheta);
                cls.def("setTheta", &Axes::setTheta);
                cls.def("clone", &Axes::clone);
                cls.def("getName", &Axes::getName);
                cls.def("normalize", &Axes::normalize);
                cls.def("readParameters", &Axes::readParameters);
                cls.def("writeParameters", &Axes::writeParameters);
                cls.def("assign", [](Axes &self, Axes &other) { self = other; });
                cls.def("assign", [](Axes &self, BaseCore &other) { self = other; });
                cls.def("transform", [](Axes &self, lsst::geom::LinearTransform const &t) {
                    return std::static_pointer_cast<Axes>(self.transform(t).copy());
                });
                cls.def("transformInPlace", [](Axes &self, lsst::geom::LinearTransform const &t) {
                    self.transform(t).inPlace();
                });
            });
}

wrapBaseCore()

void lsst::afw::geom::ellipses::wrapBaseCore

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 40 of file _baseCore.cc.

                                                                 {
    wrappers.wrapType(py::classh<BaseCore>(wrappers.module, "BaseCore"),
                      [](auto &mod, auto &cls) {
                          cls.def("__eq__", &BaseCore::operator==, py::is_operator());
                          cls.def("__nq__", &BaseCore::operator!=, py::is_operator());
                          /* Members */
                          cls.def("getName", &BaseCore::getName);
                          cls.def("clone", &BaseCore::clone);
                          cls.def("normalize", &BaseCore::normalize);
                          cls.def("grow", &BaseCore::grow);
                          cls.def("scale", &BaseCore::scale);
                          cls.def("getArea", &BaseCore::getArea);
                          cls.def("getDeterminantRadius", &BaseCore::getDeterminantRadius);
                          cls.def("getTraceRadius", &BaseCore::getTraceRadius);
                          cls.def("convolve", (BaseCore::Convolution(BaseCore::*)(BaseCore const &)) &
                                                      BaseCore::convolve);
                          cls.def("computeDimensions", &BaseCore::computeDimensions);
                          cls.def("getParameterVector", &BaseCore::getParameterVector);
                          cls.def("setParameterVector", &BaseCore::setParameterVector);
                      });
}

wrapConformalShear()

void lsst::afw::geom::ellipses::wrapConformalShear

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 39 of file _conformalShear.cc.

                                                                       {
    wrappers.wrapType(py::class_<ConformalShear, detail::EllipticityBase>(wrappers.module, "ConformalShear"),
                      [](auto &mod, auto &cls) {
                          /* Constructors */
                          cls.def(py::init<std::complex<double> const &>());
                          cls.def(py::init<double, double>(), "e1"_a = 0.0, "e2"_a = 0.0);
 
                          /* Members */
                          //    cls.def("dAssign", (Jacobian (ConformalShear::*)(Distortion const &))
                          //    &ConformalShear::dAssign); cls.def("dAssign", (Jacobian
                          //    (ConformalShear::*)(ReducedShear const &)) &ConformalShear::dAssign);
                          cls.def("getAxisRatio", &ConformalShear::getAxisRatio);
                          cls.def("normalize", &ConformalShear::normalize);
                          cls.def("getName", &ConformalShear::getName);
                          cls.def("__repr__", [](ConformalShear const &self) {
                              return py::str("{}({}, {})").format(self.getName(), self.getE1(), self.getE2());
                          });
                      });
}

wrapDistortion()

void lsst::afw::geom::ellipses::wrapDistortion

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 38 of file _distortion.cc.

                                                                   {
    wrappers.wrapType(py::class_<Distortion, detail::EllipticityBase>(wrappers.module, "Distortion"),
                      [](auto &mod, auto &cls) {
                          /* Constructors */
                          cls.def(py::init<std::complex<double> const &>());
                          cls.def(py::init<double, double>(), "e1"_a = 0.0, "e2"_a = 0.0);
 
                          /* Members */
                          //    cls.def("dAssign", (Jacobian (Distortion::*)(Distortion const &))
                          //    &Distortion::dAssign); cls.def("dAssign", (Jacobian
                          //    (Distortion::*)(ReducedShear const &)) &Distortion::dAssign);
                          cls.def("getAxisRatio", &Distortion::getAxisRatio);
                          cls.def("normalize", &Distortion::normalize);
                          cls.def("getName", &Distortion::getName);
                          cls.def("__repr__", [](Distortion const &self) {
                              return py::str("{}({}, {})").format(self.getName(), self.getE1(), self.getE2());
                          });
                      });
}

wrapEllipse()

void lsst::afw::geom::ellipses::wrapEllipse

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 44 of file _ellipse.cc.

                                                                {
    wrappers.wrapType(
            py::classh<Ellipse>(wrappers.module, "Ellipse"),
            [](auto &mod, auto &cls) {
                /* Constructors */
                cls.def(py::init<BaseCore const &, lsst::geom::Point2D const &>(), "core"_a,
                        "center"_a = lsst::geom::Point2D());
                cls.def(py::init<Ellipse const &>());
                cls.def(py::init<Ellipse::Convolution const &>());
 
                py::implicitly_convertible<Ellipse::Convolution, Ellipse>();
 
                /* Operators */
 
                /* Members */
                cls.def("getCore", [](Ellipse &ellipse) { return ellipse.getCorePtr(); });
                cls.def("getCenter", (lsst::geom::Point2D & (Ellipse::*)()) & Ellipse::getCenter);
                cls.def("setCenter", &Ellipse::setCenter);
                cls.def("setCore", &Ellipse::setCore);
                cls.def("normalize", &Ellipse::normalize);
                cls.def("grow", &Ellipse::grow);
                cls.def("scale", &Ellipse::scale);
                cls.def("shift", &Ellipse::shift);
                cls.def("getParameterVector", &Ellipse::getParameterVector);
                cls.def("setParameterVector", &Ellipse::setParameterVector);
                cls.def(
                        "transform",
                        [](Ellipse const &self, lsst::geom::AffineTransform const &t) -> Ellipse {
                            return self.transform(t);
                        },
                        "transform"_a);
                cls.def("getGridTransform", [](Ellipse &self) -> lsst::geom::AffineTransform {
                    return self.getGridTransform();  // delibarate conversion to lsst::geom::AffineTransform
                });
                cls.def("computeBBox", &Ellipse::computeBBox);
            });
}

wrapEllipticityBase()

void lsst::afw::geom::ellipses::wrapEllipticityBase

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 37 of file _ellipticityBase.cc.

                                                                        {
    wrappers.wrapType(py::class_<detail::EllipticityBase>(wrappers.module, "EllipticityBase"),
                      [](auto &mod, auto &cls) {
                          /* Member types and enums */
                          py::enum_<detail::EllipticityBase::ParameterEnum>(cls, "ParameterEnum")
                                  .value("E1", detail::EllipticityBase::ParameterEnum::E1)
                                  .value("E2", detail::EllipticityBase::ParameterEnum::E2)
                                  .export_values();
 
                          /* Members */
                          cls.def("getComplex", (std::complex<double> & (detail::EllipticityBase::*)()) &
                                                        detail::EllipticityBase::getComplex);
                          cls.def("setComplex", &detail::EllipticityBase::setComplex);
                          cls.def("getE1", &detail::EllipticityBase::getE1);
                          cls.def("setE1", &detail::EllipticityBase::setE1);
                          cls.def("getE2", &detail::EllipticityBase::getE2);
                          cls.def("setE2", &detail::EllipticityBase::setE2);
                          cls.def("getTheta", &detail::EllipticityBase::getTheta);
                          cls.def("__str__", [](detail::EllipticityBase const &self) {
                              return py::str("({}, {})").format(self.getE1(), self.getE2());
                          });
                      });
}

wrapPixelRegion()

void lsst::afw::geom::ellipses::wrapPixelRegion

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 35 of file _pixelRegion.cc.

                                                                    {
    wrappers.wrapType(py::class_<PixelRegion>(wrappers.module, "PixelRegion"), [](auto &mod, auto &cls) {
        /* Constructors */
        cls.def(py::init<Ellipse const &>());
 
        /* Members */
        cls.def("getBBox", &PixelRegion::getBBox, py::return_value_policy::copy);
        cls.def("getSpanAt", &PixelRegion::getSpanAt);
        cls.def(
                "__iter__",
                [](const PixelRegion &self) { return py::make_iterator(self.begin(), self.end()); },
                py::keep_alive<0, 1>() /* Essential: keep object alive while iterator exists */);
    });
}

wrapQuadrupole()

void lsst::afw::geom::ellipses::wrapQuadrupole

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 39 of file _quadrupole.cc.

                                                                   {
    wrappers.wrapType(
            py::classh<Quadrupole, BaseCore>(wrappers.module, "Quadrupole"),
            [](auto &mod, auto &cls) {
                /* Member types and enums */
                using Matrix = Eigen::Matrix<double, 2, 2, Eigen::DontAlign>;
 
                /* Constructors */
                cls.def(py::init<double, double, double, bool>(), "ixx"_a = 1.0, "iyy"_a = 1.0, "ixy"_a = 0.0,
                        "normalize"_a = false);
                cls.def(py::init<BaseCore::ParameterVector const &, bool>(), "vector"_a,
                        "normalize"_a = false);
                cls.def(py::init<Matrix const &, bool>(), "matrix"_a, "normalize"_a = true);
                cls.def(py::init<Quadrupole const &>());
                cls.def(py::init<BaseCore const &>());
                cls.def(py::init<BaseCore::Convolution const &>());
 
                py::implicitly_convertible<BaseCore::Convolution, Quadrupole>();
 
                /* Operators */
                cls.def(
                        "__eq__", [](Quadrupole &self, Quadrupole &other) { return self == other; },
                        py::is_operator());
                cls.def(
                        "__ne__", [](Quadrupole &self, Quadrupole &other) { return self != other; },
                        py::is_operator());
 
                /* Members */
                cls.def("getIxx", &Quadrupole::getIxx);
                cls.def("getIyy", &Quadrupole::getIyy);
                cls.def("getIxy", &Quadrupole::getIxy);
                cls.def("setIxx", &Quadrupole::setIxx);
                cls.def("setIyy", &Quadrupole::setIyy);
                cls.def("setIxy", &Quadrupole::setIxy);
                cls.def("assign", [](Quadrupole &self, Quadrupole &other) { self = other; });
                cls.def("assign", [](Quadrupole &self, BaseCore &other) { self = other; });
                cls.def("transform", [](Quadrupole &self, lsst::geom::LinearTransform const &t) {
                    return std::static_pointer_cast<Quadrupole>(self.transform(t).copy());
                });
                cls.def("transformInPlace", [](Quadrupole &self, lsst::geom::LinearTransform const &t) {
                    self.transform(t).inPlace();
                });
                // TODO: pybind11 based on swig wrapper for now. Hopefully can be removed once pybind11 gets
                // smarter handling of implicit conversions
                cls.def("convolve", [](Quadrupole &self, BaseCore const &other) {
                    return Quadrupole(self.convolve(other));
                });
            });
}

wrapRadii()

void lsst::afw::geom::ellipses::wrapRadii

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 37 of file _radii.cc.

                                                              {
    wrappers.wrapType(
            py::class_<DeterminantRadius>(wrappers.module, "DeterminantRadius"), [](auto &mod, auto &cls) {
                cls.def(py::init<double>(), "value"_a = 1.0);
                cls.def("normalize", &DeterminantRadius::normalize);
                cls.def_static("getName", DeterminantRadius::getName);
                cls.def("__str__", [](DeterminantRadius const &self) { return std::to_string(self); });
                cls.def("__repr__", [](DeterminantRadius const &self) {
                    return self.getName() + "(" + std::to_string(self) + ")";
                });
            });
 
    wrappers.wrapType(py::class_<TraceRadius>(wrappers.module, "TraceRadius"), [](auto &mod, auto &cls) {
        cls.def(py::init<double>(), "value"_a = 1.0);
        cls.def("normalize", &TraceRadius::normalize);
        cls.def_static("getName", TraceRadius::getName);
        cls.def("__str__", [](TraceRadius const &self) { return std::to_string(self); });
        cls.def("__repr__",
                [](TraceRadius const &self) { return self.getName() + "(" + std::to_string(self) + ")"; });
    });
 
    wrappers.wrapType(py::class_<LogDeterminantRadius>(wrappers.module, "LogDeterminantRadius"),
                      [](auto &mod, auto &cls) {
                          cls.def(py::init<double>(), "value"_a = 0.0);
                          cls.def("normalize", &LogDeterminantRadius::normalize);
                          cls.def_static("getName", LogDeterminantRadius::getName);
                          cls.def("__str__",
                                  [](LogDeterminantRadius const &self) { return std::to_string(self); });
                          cls.def("__repr__", [](LogDeterminantRadius const &self) {
                              return self.getName() + "(" + std::to_string(self) + ")";
                          });
                      });
 
    wrappers.wrapType(py::class_<LogTraceRadius>(wrappers.module, "LogTraceRadius"),
                      [](auto &mod, auto &cls) {
                          cls.def(py::init<double>(), "value"_a = 0.0);
                          cls.def("normalize", &LogTraceRadius::normalize);
                          cls.def_static("getName", LogTraceRadius::getName);
                          cls.def("__str__", [](LogTraceRadius const &self) { return std::to_string(self); });
                          cls.def("__repr__", [](LogTraceRadius const &self) {
                              return self.getName() + "(" + std::to_string(self) + ")";
                          });
                      });
}

wrapReducedShear()

void lsst::afw::geom::ellipses::wrapReducedShear

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 38 of file _reducedShear.cc.

                                                                     {
    wrappers.wrapType(py::class_<ReducedShear, detail::EllipticityBase>(wrappers.module, "ReducedShear"),
                      [](auto &mod, auto &cls) {
                          /* Constructors */
                          cls.def(py::init<std::complex<double> const &>());
                          cls.def(py::init<double, double>(), "e1"_a = 0.0, "e2"_a = 0.0);
 
                          /* Members */
                          //    cls.def("dAssign", (Jacobian (ReducedShear::*)(Distortion const &))
                          //    &ReducedShear::dAssign); cls.def("dAssign", (Jacobian
                          //    (ReducedShear::*)(ReducedShear const &)) &ReducedShear::dAssign);
                          cls.def("getAxisRatio", &ReducedShear::getAxisRatio);
                          cls.def("normalize", &ReducedShear::normalize);
                          cls.def("getName", &ReducedShear::getName);
                          cls.def("__repr__", [](ReducedShear const &self) {
                              return py::str("{}({}, {})").format(self.getName(), self.getE1(), self.getE2());
                          });
                      });
}

wrapSeparable()

void lsst::afw::geom::ellipses::wrapSeparable

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 82 of file _separable.cc.

                                                                  {
    declareSeparable<Distortion, DeterminantRadius>(wrappers, "DistortionDeterminantRadius");
    declareSeparable<Distortion, TraceRadius>(wrappers, "DistortionTraceRadius");
    declareSeparable<Distortion, LogDeterminantRadius>(wrappers, "DistortionLogDeterminantRadius");
    declareSeparable<Distortion, LogTraceRadius>(wrappers, "DistortionLogTraceRadius");
 
    declareSeparable<ConformalShear, DeterminantRadius>(wrappers, "ConformalShearDeterminantRadius");
    declareSeparable<ConformalShear, TraceRadius>(wrappers, "ConformalShearTraceRadius");
    declareSeparable<ConformalShear, LogDeterminantRadius>(wrappers, "ConformalShearLogDeterminantRadius");
    declareSeparable<ConformalShear, LogTraceRadius>(wrappers, "ConformalShearLogTraceRadius");
 
    declareSeparable<ReducedShear, DeterminantRadius>(wrappers, "ReducedShearDeterminantRadius");
    declareSeparable<ReducedShear, TraceRadius>(wrappers, "ReducedShearTraceRadius");
    declareSeparable<ReducedShear, LogDeterminantRadius>(wrappers, "ReducedShearLogDeterminantRadius");
    declareSeparable<ReducedShear, LogTraceRadius>(wrappers, "ReducedShearLogTraceRadius");
}

Variable Documentation

MatplotlibInterface

lsst.afw.geom.ellipses.MatplotlibInterface

Definition at line 128 of file __init__.py.

plot

lsst.afw.geom.ellipses.plot

Definition at line 129 of file __init__.py.

Separable

dict lsst.afw.geom.ellipses.Separable

Initial value:

=  {
    (Distortion, DeterminantRadius): SeparableDistortionDeterminantRadius,
    (Distortion, TraceRadius): SeparableDistortionTraceRadius,
    (Distortion, LogDeterminantRadius): SeparableDistortionLogDeterminantRadius,
    (Distortion, LogTraceRadius): SeparableDistortionLogTraceRadius,
    (ConformalShear, DeterminantRadius): SeparableConformalShearDeterminantRadius,
    (ConformalShear, TraceRadius): SeparableConformalShearTraceRadius,
    (ConformalShear, LogDeterminantRadius): SeparableConformalShearLogDeterminantRadius,
    (ConformalShear, LogTraceRadius): SeparableConformalShearLogTraceRadius
}

Definition at line 30 of file __init__.py.

Separable< Ellipticity_, Radius_ >::registrar

template<typename Ellipticity_, typename Radius_>

BaseCore::Registrar<Separable<Ellipticity_, Radius_> > lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::registrar

Definition at line 36 of file Separable.cc.