lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ > Class Template Reference

An ellipse core with a complex ellipticity and radius parameterization. More...

#include <Separable.h>

Inheritance diagram for lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >:

Public Types
enum	ParameterEnum { E1 = 0 , E2 = 1 , RADIUS = 2 }
using	Ellipticity = Ellipticity_
using	Radius = Radius_
using	ParameterVector = Eigen::Vector3d
	Parameter vector type.
using	Jacobian = Eigen::Matrix3d
	Parameter Jacobian matrix type.

Public Member Functions
double const	getE1 () const
void	setE1 (double e1)
double const	getE2 () const
void	setE2 (double e2)
Radius const &	getRadius () const
Radius &	getRadius ()
void	setRadius (double radius)
void	setRadius (Radius const &radius)
Ellipticity const &	getEllipticity () const
Ellipticity &	getEllipticity ()
std::shared_ptr< Separable >	clone () const
	Deep copy the ellipse core.
std::string	getName () const override
	Return a string that identifies this parametrization.
void	normalize () override
	Put the parameters into a "standard form", and throw InvalidParameterError if they cannot be normalized.
void	readParameters (double const *iter) override
	Return the size of the bounding box for the ellipse core.
void	writeParameters (double *iter) const override
	Return the size of the bounding box for the ellipse core.
Separable &	operator= (Separable const &other)
	Standard assignment.
Separable &	operator= (Separable &&other)
Separable &	operator= (BaseCore const &other)
	Converting assignment.
	Separable (double e1=0.0, double e2=0.0, double radius=Radius(), bool normalize=true)
	Construct from parameter values.
	Separable (std::complex< double > const &complex, double radius=Radius(), bool normalize=true)
	Construct from parameter values.
	Separable (Ellipticity const &ellipticity, double radius=Radius(), bool normalize=true)
	Construct from parameter values.
	Separable (BaseCore::ParameterVector const &vector, bool normalize=false)
	Construct from a parameter vector.
	Separable (Separable const &other)
	Copy constructor.
	Separable (Separable &&other)
	~Separable () override=default
	Separable (BaseCore const &other)
	Converting copy constructor.
	Separable (BaseCore::Transformer const &transformer)
	Converting copy constructor.
	Separable (BaseCore::Convolution const &convolution)
	Converting copy constructor.
void	grow (double buffer)
	Increase the major and minor radii of the ellipse core by the given buffer.
void	scale (double factor)
	Scale the size of the ellipse core by the given factor.
double	getArea () const
	Return the area of the ellipse core.
double	getDeterminantRadius () const
	Return the radius defined as the 4th root of the determinant of the quadrupole matrix.
double	getTraceRadius () const
	Return the radius defined as the square root of one half the trace of the quadrupole matrix.
Coordinate transforms
These member functions transform the ellipse by the given lsst::geom::LinearTransform. The transform can be done in-place by calling inPlace() on the returned expression object, or returned as a new shared_ptr by calling copy().
Transformer	transform (lsst::geom::LinearTransform const &transform)
	Return the transform that maps the ellipse to the unit circle.
Transformer const	transform (lsst::geom::LinearTransform const &transform) const
	Return the transform that maps the ellipse to the unit circle.
GridTransform const	getGridTransform () const
	Return the transform that maps the ellipse to the unit circle.

Static Public Member Functions
static std::shared_ptr< BaseCore >	make (std::string const &name)
static std::shared_ptr< BaseCore >	make (std::string const &name, ParameterVector const &parameters)
static std::shared_ptr< BaseCore >	make (std::string const &name, double v1, double v2, double v3)
static std::shared_ptr< BaseCore >	make (std::string const &name, BaseCore const &other)
static std::shared_ptr< BaseCore >	make (std::string const &name, Transformer const &other)
static std::shared_ptr< BaseCore >	make (std::string const &name, Convolution const &other)

Protected Member Functions
std::shared_ptr< BaseCore >	_clone () const override
	Return the size of the bounding box for the ellipse core.
void	_assignToQuadrupole (double &ixx, double &iyy, double &ixy) const override
	Return the size of the bounding box for the ellipse core.
void	_assignFromQuadrupole (double ixx, double iyy, double ixy) override
	Return the size of the bounding box for the ellipse core.
void	_assignToAxes (double &a, double &b, double &theta) const override
	Return the size of the bounding box for the ellipse core.
void	_assignFromAxes (double a, double b, double theta) override
	Return the size of the bounding box for the ellipse core.
Jacobian	_dAssignToQuadrupole (double &ixx, double &iyy, double &ixy) const override
	Return the size of the bounding box for the ellipse core.
Jacobian	_dAssignFromQuadrupole (double ixx, double iyy, double ixy) override
	Return the size of the bounding box for the ellipse core.
Jacobian	_dAssignToAxes (double &a, double &b, double &theta) const override
	Return the size of the bounding box for the ellipse core.
Jacobian	_dAssignFromAxes (double a, double b, double theta) override
	Return the size of the bounding box for the ellipse core.

Convolve two bivariate Gaussians defined by their 1-sigma ellipses.
Convolution	convolve (BaseCore const &other)
	Return the size of the bounding box for the ellipse core.
Convolution const	convolve (BaseCore const &other) const
	Return the size of the bounding box for the ellipse core.
lsst::geom::Extent2D	computeDimensions () const
	Return the size of the bounding box for the ellipse core.
ParameterVector const	getParameterVector () const
	Return the core parameters as a vector.
void	setParameterVector (ParameterVector const &vector)
	Set the core parameters from a vector.
bool	operator== (BaseCore const &other) const
	Compare two ellipse cores for equality.
bool	operator!= (BaseCore const &other) const
	Compare two ellipse cores for inequality.
Jacobian	dAssign (BaseCore const &other)
	Assign other to this and return the derivative of the conversion, d(this)/d(other).
template<typename Output>
Converter< Output >	as () const
	Convert this to the core type specified as a template parameter.
static void	registerSubclass (std::shared_ptr< BaseCore > const &example)
	Return the size of the bounding box for the ellipse core.
static void	_assignQuadrupoleToAxes (double ixx, double iyy, double ixy, double &a, double &b, double &theta)
	Return the size of the bounding box for the ellipse core.
static Jacobian	_dAssignQuadrupoleToAxes (double ixx, double iyy, double ixy, double &a, double &b, double &theta)
	Return the size of the bounding box for the ellipse core.
static void	_assignAxesToQuadrupole (double a, double b, double theta, double &ixx, double &iyy, double &ixy)
	Return the size of the bounding box for the ellipse core.
static Jacobian	_dAssignAxesToQuadrupole (double a, double b, double theta, double &ixx, double &iyy, double &ixy)
	Return the size of the bounding box for the ellipse core.

Detailed Description

template<typename Ellipticity_, typename Radius_>
class lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >

An ellipse core with a complex ellipticity and radius parameterization.

Definition at line 50 of file Separable.h.

Member Typedef Documentation

Ellipticity

template<typename Ellipticity_, typename Radius_>

using lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Ellipticity = Ellipticity_

Definition at line 54 of file Separable.h.

Jacobian

using lsst::afw::geom::ellipses::BaseCore::Jacobian = Eigen::Matrix3d

inherited

Parameter Jacobian matrix type.

Definition at line 64 of file BaseCore.h.

ParameterVector

using lsst::afw::geom::ellipses::BaseCore::ParameterVector = Eigen::Vector3d

inherited

Parameter vector type.

Definition at line 63 of file BaseCore.h.

Radius

template<typename Ellipticity_, typename Radius_>

using lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Radius = Radius_

Definition at line 55 of file Separable.h.

Member Enumeration Documentation

ParameterEnum

template<typename Ellipticity_, typename Radius_>

enum lsst::afw::geom::ellipses::Separable::ParameterEnum

Enumerator
E1
E2
RADIUS

Definition at line 52 of file Separable.h.

{ E1 = 0, E2 = 1, RADIUS = 2 };  

Constructor & Destructor Documentation

Separable() [1/9]

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Separable ( double e1 = 0.0, double e2 = 0.0, double radius = Radius(), bool normalize = true )

explicit

Construct from parameter values.

Definition at line 78 of file Separable.cc.

        : _ellipticity(e1, e2), _radius(radius) {
    if (normalize) this->normalize();
}

Separable() [2/9]

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Separable ( std::complex< double > const & complex, double radius = Radius(), bool normalize = true )

explicit

Construct from parameter values.

Definition at line 84 of file Separable.cc.

        : _ellipticity(complex), _radius(radius) {
    if (normalize) this->normalize();
}

Separable() [3/9]

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Separable ( Ellipticity const & ellipticity, double radius = Radius(), bool normalize = true )

explicit

Construct from parameter values.

Definition at line 91 of file Separable.cc.

        : _ellipticity(ellipticity), _radius(radius) {
    if (normalize) this->normalize();
}

Separable() [4/9]

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Separable ( BaseCore::ParameterVector const & vector, bool normalize = false )

explicit

Construct from a parameter vector.

Definition at line 97 of file Separable.cc.

        : _ellipticity(vector[0], vector[1]), _radius(vector[2]) {
    if (normalize) this->normalize();
}

Separable() [5/9]

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Separable ( Separable< Ellipticity_, Radius_ > const & other )

inline

Copy constructor.

Definition at line 111 of file Separable.h.

: _ellipticity(other._ellipticity), _radius(other._radius) {}

Separable() [6/9]

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Separable ( Separable< Ellipticity_, Radius_ > && other )

inline

Definition at line 114 of file Separable.h.

: Separable(other) {}

~Separable()

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::~Separable ( )

overridedefault

Separable() [7/9]

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Separable ( BaseCore const & other )

inline

Converting copy constructor.

Definition at line 119 of file Separable.h.

{ *this = other; }

Separable() [8/9]

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Separable ( BaseCore::Transformer const & transformer )

inline

Converting copy constructor.

Definition at line 122 of file Separable.h.

{ transformer.apply(*this); }

Separable() [9/9]

template<typename Ellipticity_, typename Radius_>

lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::Separable ( BaseCore::Convolution const & convolution )

inline

Converting copy constructor.

Definition at line 125 of file Separable.h.

{ convolution.apply(*this); }

Member Function Documentation

_assignAxesToQuadrupole()

void lsst::afw::geom::ellipses::BaseCore::_assignAxesToQuadrupole ( double a, double b, double theta, double & ixx, double & iyy, double & ixy )

staticprotectedinherited

Return the size of the bounding box for the ellipse core.

Definition at line 218 of file BaseCore.cc.

                                                    {
    a *= a;
    b *= b;
    double c = std::cos(theta);
    double s = std::sin(theta);
    ixy = (a - b) * c * s;
    c *= c;
    s *= s;
    ixx = c * a + s * b;
    iyy = s * a + c * b;
}

_assignFromAxes()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::_assignFromAxes ( double a, double b, double theta )

overrideprotectedvirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 152 of file Separable.cc.

                                                                                       {
    double ixx, iyy, ixy;
    BaseCore::_assignAxesToQuadrupole(a, b, theta, ixx, iyy, ixy);
    this->_assignFromQuadrupole(ixx, iyy, ixy);
}

_assignFromQuadrupole()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::_assignFromQuadrupole ( double ixx, double iyy, double ixy )

overrideprotectedvirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 135 of file Separable.cc.

                                                                                               {
    Distortion distortion;
    _radius.assignFromQuadrupole(ixx, iyy, ixy, distortion);
    _ellipticity = distortion;
}

_assignQuadrupoleToAxes()

void lsst::afw::geom::ellipses::BaseCore::_assignQuadrupoleToAxes ( double ixx, double iyy, double ixy, double & a, double & b, double & theta )

staticprotectedinherited

Return the size of the bounding box for the ellipse core.

Definition at line 183 of file BaseCore.cc.

                                                      {
    double xx_p_yy = ixx + iyy;
    double xx_m_yy = ixx - iyy;
    double t = std::sqrt(xx_m_yy * xx_m_yy + 4 * ixy * ixy);
    a = std::sqrt(0.5 * (xx_p_yy + t));
    b = std::sqrt(0.5 * (xx_p_yy - t));
    theta = 0.5 * std::atan2(2.0 * ixy, xx_m_yy);
}

_assignToAxes()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::_assignToAxes ( double & a, double & b, double & theta ) const

overrideprotectedvirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 119 of file Separable.cc.

                                                                                              {
    double ixx, iyy, ixy;
    this->_assignToQuadrupole(ixx, iyy, ixy);
    BaseCore::_assignQuadrupoleToAxes(ixx, iyy, ixy, a, b, theta);
}

_assignToQuadrupole()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::_assignToQuadrupole ( double & ixx, double & iyy, double & ixy ) const

overrideprotectedvirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 103 of file Separable.cc.

                                                                                                      {
    Distortion distortion(_ellipticity);
    _radius.assignToQuadrupole(distortion, ixx, iyy, ixy);
}

_clone()

template<typename Ellipticity_, typename Radius_>

std::shared_ptr< BaseCore > lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::_clone ( ) const

inlineoverrideprotectedvirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 128 of file Separable.h.

{ return std::make_shared<Separable>(*this); }

_dAssignAxesToQuadrupole()

BaseCore::Jacobian lsst::afw::geom::ellipses::BaseCore::_dAssignAxesToQuadrupole ( double a, double b, double theta, double & ixx, double & iyy, double & ixy )

staticprotectedinherited

Return the size of the bounding box for the ellipse core.

Definition at line 231 of file BaseCore.cc.

                                                                                {
    Jacobian m;
    m.col(0).setConstant(2 * a);
    m.col(1).setConstant(2 * b);
    a *= a;
    b *= b;
    m.col(2).setConstant(a - b);
    double c = std::cos(theta);
    double s = std::sin(theta);
    double cs = c * s;
    ixy = (a - b) * c * s;
    c *= c;
    s *= s;
    ixx = c * a + s * b;
    iyy = s * a + c * b;
    m(0, 0) *= c;
    m(0, 1) *= s;
    m(0, 2) *= -2.0 * cs;
    m(1, 0) *= s;
    m(1, 1) *= c;
    m(1, 2) *= 2.0 * cs;
    m(2, 0) *= cs;
    m(2, 1) *= -cs;
    m(2, 2) *= (c - s);
    return m;
}

_dAssignFromAxes()

template<typename Ellipticity_, typename Radius_>

BaseCore::Jacobian lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::_dAssignFromAxes ( double a, double b, double theta )

overrideprotectedvirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 159 of file Separable.cc.

                                                                                                    {
    double ixx, iyy, ixy;
    BaseCore::Jacobian rhs = BaseCore::_dAssignAxesToQuadrupole(a, b, theta, ixx, iyy, ixy);
    BaseCore::Jacobian lhs = this->_dAssignFromQuadrupole(ixx, iyy, ixy);
    return lhs * rhs;
}

_dAssignFromQuadrupole()

template<typename Ellipticity_, typename Radius_>

BaseCore::Jacobian lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::_dAssignFromQuadrupole ( double ixx, double iyy, double ixy )

overrideprotectedvirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 142 of file Separable.cc.

                                                                                        {
    Distortion distortion;
    BaseCore::Jacobian rhs = _radius.dAssignFromQuadrupole(ixx, iyy, ixy, distortion);
    BaseCore::Jacobian lhs = BaseCore::Jacobian::Identity();
    lhs.block<2, 2>(0, 0) = _ellipticity.dAssign(distortion);
    return lhs * rhs;
}

_dAssignQuadrupoleToAxes()

BaseCore::Jacobian lsst::afw::geom::ellipses::BaseCore::_dAssignQuadrupoleToAxes ( double ixx, double iyy, double ixy, double & a, double & b, double & theta )

staticprotectedinherited

Return the size of the bounding box for the ellipse core.

Definition at line 193 of file BaseCore.cc.

                                                                                {
    double xx_p_yy = ixx + iyy;
    double xx_m_yy = ixx - iyy;
    double t2 = xx_m_yy * xx_m_yy + 4.0 * ixy * ixy;
    Eigen::Vector3d dt2(2.0 * xx_m_yy, -2.0 * xx_m_yy, 8.0 * ixy);
    double t = std::sqrt(t2);
    a = std::sqrt(0.5 * (xx_p_yy + t));
    b = std::sqrt(0.5 * (xx_p_yy - t));
    theta = 0.5 * std::atan2(2.0 * ixy, xx_m_yy);
    Jacobian m = Jacobian::Zero();
    m(0, 0) = 0.25 * (1.0 + 0.5 * dt2[0] / t) / a;
    m(0, 1) = 0.25 * (1.0 + 0.5 * dt2[1] / t) / a;
    m(0, 2) = 0.25 * (0.5 * dt2[2] / t) / a;
    m(1, 0) = 0.25 * (1.0 - 0.5 * dt2[0] / t) / b;
    m(1, 1) = 0.25 * (1.0 - 0.5 * dt2[1] / t) / b;
    m(1, 2) = 0.25 * (-0.5 * dt2[2] / t) / b;
 
    m.row(2).setConstant(1.0 / (t * t));
    m(2, 0) *= -ixy;
    m(2, 1) *= ixy;
    m(2, 2) *= xx_m_yy;
    return m;
}

_dAssignToAxes()

template<typename Ellipticity_, typename Radius_>

BaseCore::Jacobian lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::_dAssignToAxes ( double & a, double & b, double & theta ) const

overrideprotectedvirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 126 of file Separable.cc.

                                                                                         {
    double ixx, iyy, ixy;
    BaseCore::Jacobian rhs = this->_dAssignToQuadrupole(ixx, iyy, ixy);
    BaseCore::Jacobian lhs = BaseCore::_dAssignQuadrupoleToAxes(ixx, iyy, ixy, a, b, theta);
    return lhs * rhs;
}

_dAssignToQuadrupole()

template<typename Ellipticity_, typename Radius_>

BaseCore::Jacobian lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::_dAssignToQuadrupole ( double & ixx, double & iyy, double & ixy ) const

overrideprotectedvirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 109 of file Separable.cc.

                                                                                             {
    Distortion distortion;
    BaseCore::Jacobian rhs = Jacobian::Identity();
    rhs.block<2, 2>(0, 0) = distortion.dAssign(_ellipticity);
    BaseCore::Jacobian lhs = _radius.dAssignToQuadrupole(distortion, ixx, iyy, ixy);
    return lhs * rhs;
}

as()

template<typename Output>

BaseCore::Converter< Output > lsst::afw::geom::ellipses::BaseCore::as ( ) const

inlineinherited

Convert this to the core type specified as a template parameter.

Definition at line 238 of file BaseCore.h.

                                                    {
    return Converter<Output>(*this);
}

clone()

template<typename Ellipticity_, typename Radius_>

std::shared_ptr< Separable > lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::clone ( ) const

inline

Deep copy the ellipse core.

Definition at line 72 of file Separable.h.

{ return std::static_pointer_cast<Separable>(_clone()); }

computeDimensions()

lsst::geom::Extent2D lsst::afw::geom::ellipses::BaseCore::computeDimensions ( ) const

inherited

Return the size of the bounding box for the ellipse core.

Definition at line 129 of file BaseCore.cc.

                                                   {
    double a, b, theta;
    _assignToAxes(a, b, theta);
    double c = std::cos(theta);
    double s = std::sin(theta);
    c *= c;
    s *= s;
    b *= b;
    a *= a;
    lsst::geom::Extent2D dimensions(std::sqrt(b * s + a * c), std::sqrt(a * s + b * c));
    dimensions *= 2;
    return dimensions;
}

convolve() [1/2]

BaseCore::Convolution lsst::afw::geom::ellipses::BaseCore::convolve ( BaseCore const & other )

inlineinherited

Return the size of the bounding box for the ellipse core.

Definition at line 91 of file Convolution.h.

                                                                   {
    return BaseCore::Convolution(*this, other);
}

convolve() [2/2]

BaseCore::Convolution const lsst::afw::geom::ellipses::BaseCore::convolve ( BaseCore const & other ) const

inlineinherited

Return the size of the bounding box for the ellipse core.

Definition at line 95 of file Convolution.h.

                                                                               {
    return BaseCore::Convolution(const_cast<BaseCore &>(*this), other);
}

dAssign()

BaseCore::Jacobian lsst::afw::geom::ellipses::BaseCore::dAssign ( BaseCore const & other )

inherited

Assign other to this and return the derivative of the conversion, d(this)/d(other).

Definition at line 168 of file BaseCore.cc.

                                                        {
    if (getName() == other.getName()) {
        this->operator=(other);
        return Jacobian::Identity();
    }
    // We use Quadrupole instead of Axes here because the ambiguity of the position angle
    // in the circular case causes some of the Jacobians to/from Axes to be undefined for
    // exact circles.  Quadrupoles don't have that problem, and the Axes-to-Axes case is
    // handled by the above if block.
    double ixx, iyy, ixy;
    Jacobian rhs = other._dAssignToQuadrupole(ixx, iyy, ixy);
    Jacobian lhs = _dAssignFromQuadrupole(ixx, iyy, ixy);
    return lhs * rhs;
}

getArea()

double lsst::afw::geom::ellipses::BaseCore::getArea ( ) const

inherited

Return the area of the ellipse core.

Definition at line 111 of file BaseCore.cc.

                               {
    double a, b, theta;
    _assignToAxes(a, b, theta);
    return a * b * lsst::geom::PI;
}

getDeterminantRadius()

double lsst::afw::geom::ellipses::BaseCore::getDeterminantRadius ( ) const

inherited

Return the radius defined as the 4th root of the determinant of the quadrupole matrix.

The determinant radius is equal to the standard radius for a circle, and its square times pi is the area of the ellipse.

Definition at line 117 of file BaseCore.cc.

                                            {
    double a, b, theta;
    _assignToAxes(a, b, theta);
    return std::sqrt(a * b);
}

getE1()

template<typename Ellipticity_, typename Radius_>

double const lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::getE1 ( ) const

inline

Definition at line 57 of file Separable.h.

{ return _ellipticity.getE1(); }

getE2()

template<typename Ellipticity_, typename Radius_>

double const lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::getE2 ( ) const

inline

Definition at line 60 of file Separable.h.

{ return _ellipticity.getE2(); }

getEllipticity() [1/2]

template<typename Ellipticity_, typename Radius_>

Ellipticity & lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::getEllipticity ( )

inline

Definition at line 69 of file Separable.h.

{ return _ellipticity; }

getEllipticity() [2/2]

template<typename Ellipticity_, typename Radius_>

Ellipticity const & lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::getEllipticity ( ) const

inline

Definition at line 68 of file Separable.h.

{ return _ellipticity; }

getGridTransform()

BaseCore::GridTransform const lsst::afw::geom::ellipses::BaseCore::getGridTransform ( ) const

inlineinherited

Return the transform that maps the ellipse to the unit circle.

The returned proxy object is implicitly convertible to lsst::geom::LinearTransform and also supports differentiation.

Definition at line 110 of file GridTransform.h.

                                                                    {
    return BaseCore::GridTransform(*this);
}

getName()

template<typename Ellipticity_, typename Radius_>

std::string lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::getName ( ) const

overridevirtual

Return a string that identifies this parametrization.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 39 of file Separable.cc.

                                                          {
    return "Separable" + Ellipticity_::getName() + Radius_::getName();
}

getParameterVector()

BaseCore::ParameterVector const lsst::afw::geom::ellipses::BaseCore::getParameterVector ( ) const

inherited

Return the core parameters as a vector.

Definition at line 143 of file BaseCore.cc.

                                                                 {
    ParameterVector r;
    writeParameters(r.data());
    return r;
}

getRadius() [1/2]

template<typename Ellipticity_, typename Radius_>

Radius & lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::getRadius ( )

inline

Definition at line 64 of file Separable.h.

{ return _radius; }

getRadius() [2/2]

template<typename Ellipticity_, typename Radius_>

Radius const & lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::getRadius ( ) const

inline

Definition at line 63 of file Separable.h.

{ return _radius; }

getTraceRadius()

double lsst::afw::geom::ellipses::BaseCore::getTraceRadius ( ) const

inherited

Return the radius defined as the square root of one half the trace of the quadrupole matrix.

The trace radius is equal to the standard radius for a circle.

Definition at line 123 of file BaseCore.cc.

                                      {
    double ixx, iyy, ixy;
    _assignToQuadrupole(ixx, iyy, ixy);
    return std::sqrt(0.5 * (ixx + iyy));
}

grow()

void lsst::afw::geom::ellipses::BaseCore::grow ( double buffer )

inherited

Increase the major and minor radii of the ellipse core by the given buffer.

Definition at line 95 of file BaseCore.cc.

                                 {
    double a, b, theta;
    _assignToAxes(a, b, theta);
    a += buffer;
    b += buffer;
    _assignFromAxes(a, b, theta);
}

make() [1/6]

std::shared_ptr< BaseCore > lsst::afw::geom::ellipses::BaseCore::make ( std::string const & name )

staticinherited

Definition at line 55 of file BaseCore.cc.

                                                            {
    std::shared_ptr<BaseCore> result = getRegistryCopy(name);
    *result = Quadrupole();
    return result;
}

make() [2/6]

std::shared_ptr< BaseCore > lsst::afw::geom::ellipses::BaseCore::make ( std::string const & name, BaseCore const & other )

staticinherited

Definition at line 73 of file BaseCore.cc.

                                                                                   {
    std::shared_ptr<BaseCore> result = getRegistryCopy(name);
    *result = other;
    return result;
}

make() [3/6]

std::shared_ptr< BaseCore > lsst::afw::geom::ellipses::BaseCore::make ( std::string const & name, Convolution const & other )

staticinherited

Definition at line 85 of file BaseCore.cc.

                                                                                      {
    std::shared_ptr<BaseCore> result = getRegistryCopy(name);
    other.apply(*result);
    return result;
}

make() [4/6]

std::shared_ptr< BaseCore > lsst::afw::geom::ellipses::BaseCore::make ( std::string const & name, double v1, double v2, double v3 )

staticinherited

Definition at line 67 of file BaseCore.cc.

                                                                                             {
    std::shared_ptr<BaseCore> result = getRegistryCopy(name);
    result->setParameterVector(ParameterVector(v1, v2, v3));
    return result;
}

make() [5/6]

std::shared_ptr< BaseCore > lsst::afw::geom::ellipses::BaseCore::make ( std::string const & name, ParameterVector const & parameters )

staticinherited

Definition at line 61 of file BaseCore.cc.

                                                                                               {
    std::shared_ptr<BaseCore> result = getRegistryCopy(name);
    result->setParameterVector(parameters);
    return result;
}

make() [6/6]

std::shared_ptr< BaseCore > lsst::afw::geom::ellipses::BaseCore::make ( std::string const & name, Transformer const & other )

staticinherited

Definition at line 79 of file BaseCore.cc.

                                                                                      {
    std::shared_ptr<BaseCore> result = getRegistryCopy(name);
    other.apply(*result);
    return result;
}

normalize()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::normalize ( )

overridevirtual

Put the parameters into a "standard form", and throw InvalidParameterError if they cannot be normalized.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 44 of file Separable.cc.

                                                 {
    _ellipticity.normalize();
    _radius.normalize();
}

operator!=()

bool lsst::afw::geom::ellipses::BaseCore::operator!= ( BaseCore const & other ) const

inlineinherited

Compare two ellipse cores for inequality.

Ellipses are only equal if they have the same type.

Definition at line 167 of file BaseCore.h.

{ return !operator==(other); }

operator=() [1/3]

template<typename Ellipticity_, typename Radius_>

Separable & lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::operator= ( BaseCore const & other )

inline

Converting assignment.

Definition at line 93 of file Separable.h.

                                                {
        BaseCore::operator=(other);
        return *this;
    }

operator=() [2/3]

template<typename Ellipticity_, typename Radius_>

Separable< Ellipticity_, Radius_ > & lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::operator=

(

Separable< Ellipticity_, Radius_ > &&

other

)

Definition at line 73 of file Separable.cc.

                                                  {
    return *this = other;
}

operator=() [3/3]

template<typename Ellipticity_, typename Radius_>

Separable< Ellipticity_, Radius_ > & lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::operator=

(

Separable< Ellipticity_, Radius_ > const &

other

)

Standard assignment.

Definition at line 64 of file Separable.cc.

                                                       {
    _ellipticity = other._ellipticity;
    _radius = other._radius;
    return *this;
}

operator==()

bool lsst::afw::geom::ellipses::BaseCore::operator== ( BaseCore const & other ) const

inherited

Compare two ellipse cores for equality.

Ellipse cores are only equal if they have the same type.

Definition at line 151 of file BaseCore.cc.

                                                     {
    return getParameterVector() == other.getParameterVector() && getName() == other.getName();
}

readParameters()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::readParameters ( double const * iter )

overridevirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 50 of file Separable.cc.

                                                                        {
    setE1(*iter++);
    setE2(*iter++);
    setRadius(*iter++);
}

registerSubclass()

void lsst::afw::geom::ellipses::BaseCore::registerSubclass ( std::shared_ptr< BaseCore > const & example )

staticprotectedinherited

Return the size of the bounding box for the ellipse core.

Definition at line 91 of file BaseCore.cc.

                                                                      {
    getRegistry()[example->getName()] = example;
}

scale()

void lsst::afw::geom::ellipses::BaseCore::scale ( double factor )

inherited

Scale the size of the ellipse core by the given factor.

Definition at line 103 of file BaseCore.cc.

                                  {
    double a, b, theta;
    _assignToAxes(a, b, theta);
    a *= factor;
    b *= factor;
    _assignFromAxes(a, b, theta);
}

setE1()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::setE1 ( double e1 )

inline

Definition at line 58 of file Separable.h.

{ _ellipticity.setE1(e1); }

setE2()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::setE2 ( double e2 )

inline

Definition at line 61 of file Separable.h.

{ _ellipticity.setE2(e2); }

setParameterVector()

void lsst::afw::geom::ellipses::BaseCore::setParameterVector ( ParameterVector const & vector )

inherited

Set the core parameters from a vector.

Definition at line 149 of file BaseCore.cc.

{ readParameters(p.data()); }

setRadius() [1/2]

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::setRadius ( double radius )

inline

Definition at line 65 of file Separable.h.

{ _radius = radius; }

setRadius() [2/2]

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::setRadius ( Radius const & radius )

inline

Definition at line 66 of file Separable.h.

{ _radius = radius; }

transform() [1/2]

BaseCore::Transformer lsst::afw::geom::ellipses::BaseCore::transform ( lsst::geom::LinearTransform const & transform )

inlineinherited

Return the transform that maps the ellipse to the unit circle.

The returned proxy object is implicitly convertible to lsst::geom::LinearTransform and also supports differentiation.

Definition at line 116 of file Transformer.h.

                                                                                       {
    return BaseCore::Transformer(*this, transform);
}

transform() [2/2]

BaseCore::Transformer const lsst::afw::geom::ellipses::BaseCore::transform ( lsst::geom::LinearTransform const & transform ) const

inlineinherited

Return the transform that maps the ellipse to the unit circle.

The returned proxy object is implicitly convertible to lsst::geom::LinearTransform and also supports differentiation.

Definition at line 120 of file Transformer.h.

                                                                                                   {
    return BaseCore::Transformer(const_cast<BaseCore &>(*this), transform);
}

writeParameters()

template<typename Ellipticity_, typename Radius_>

void lsst::afw::geom::ellipses::Separable< Ellipticity_, Radius_ >::writeParameters ( double * iter ) const

overridevirtual

Return the size of the bounding box for the ellipse core.

Implements lsst::afw::geom::ellipses::BaseCore.

Definition at line 57 of file Separable.cc.

                                                                         {
    *iter++ = getE1();
    *iter++ = getE2();
    *iter++ = getRadius();
}

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/afw/gdb1c4ca869+16879ca1a6/include/lsst/afw/geom/ellipses/radii.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/afw/gdb1c4ca869+16879ca1a6/include/lsst/afw/geom/ellipses/Separable.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/afw/gdb1c4ca869+16879ca1a6/src/geom/ellipses/Separable.cc