lsst::meas::astrom::PolynomialTransform Class Reference

A 2-d coordinate transform represented by a pair of standard polynomials (one for each coordinate). More...

#include <PolynomialTransform.h>

Public Member Functions
	PolynomialTransform (ndarray::Array< double const, 2, 0 > const &xCoeffs, ndarray::Array< double const, 2, 0 > const &yCoeffs)
	Construct a new transform from existing coefficient arrays.
	PolynomialTransform (PolynomialTransform const &other)
	Copy constructor.
	PolynomialTransform (PolynomialTransform &&other)
	Move constructor.
PolynomialTransform &	operator= (PolynomialTransform const &other)
	Copy assignment.
PolynomialTransform &	operator= (PolynomialTransform &&other)
	Move constructor.
void	swap (PolynomialTransform &other)
	Lightweight swap.
int	getOrder () const
	Return the order of the polynomials.
ndarray::Array< double const, 2, 2 >	getXCoeffs () const
	2-D polynomial coefficients that compute the output x coordinate.
ndarray::Array< double const, 2, 2 >	getYCoeffs () const
	2-D polynomial coefficients that compute the output x coordinate.
geom::AffineTransform	linearize (geom::Point2D const &in) const
	Return an approximate affine transform at the given point.
geom::Point2D	operator() (geom::Point2D const &in) const
	Apply the transform to a point.

Static Public Member Functions
static PolynomialTransform	convert (ScaledPolynomialTransform const &other)
	Convert a ScaledPolynomialTransform to an equivalent PolynomialTransform.
static PolynomialTransform	convert (SipForwardTransform const &other)
	Convert a SipForwardTransform to an equivalent PolynomialTransform.
static PolynomialTransform	convert (SipReverseTransform const &other)
	Convert a SipReverseTransform to an equivalent PolynomialTransform.

Friends
class	ScaledPolynomialTransformFitter
class	SipForwardTransform
class	SipReverseTransform
class	ScaledPolynomialTransform
PolynomialTransform	compose (geom::AffineTransform const &t1, PolynomialTransform const &t2)
	Return a PolynomialTransform that is equivalent to the composition t1(t2())
PolynomialTransform	compose (PolynomialTransform const &t1, geom::AffineTransform const &t2)
	Return a PolynomialTransform that is equivalent to the composition t1(t2())

Related Symbols
(Note that these are not member symbols.)
	compose

Detailed Description

A 2-d coordinate transform represented by a pair of standard polynomials (one for each coordinate).

PolynomialTransform instances should be confined to a single thread.

Definition at line 45 of file PolynomialTransform.h.

Constructor & Destructor Documentation

PolynomialTransform() [1/3]

lsst::meas::astrom::PolynomialTransform::PolynomialTransform	(	ndarray::Array< double const, 2, 0 > const &	xCoeffs,
		ndarray::Array< double const, 2, 0 > const &	yCoeffs )

Construct a new transform from existing coefficient arrays.

For both input arguments, the array element at [p, q] corresponds to the polynomial term x^p y^q.

Both arrays are expected be square and triangular; if N is the order of the transform, both arrays should be (N+1)x(N+1), and elements with p + q > N should be zero.

Definition at line 74 of file PolynomialTransform.cc.

        : _xCoeffs(ndarray::copy(xCoeffs)),
          _yCoeffs(ndarray::copy(yCoeffs)),
          _u(_xCoeffs.getSize<0>()),
          _v(_xCoeffs.getSize<0>()) {
    if (xCoeffs.getShape() != yCoeffs.getShape()) {
        throw LSST_EXCEPT(
                pex::exceptions::LengthError,
                (boost::format("X and Y coefficient matrices must have the same shape: "
                               " (%d,%d) != (%d,%d)") %
                 xCoeffs.getSize<0>() % xCoeffs.getSize<1>() % yCoeffs.getSize<0>() % yCoeffs.getSize<1>())
                        .str());
    }
    if (_xCoeffs.getSize<1>() != _xCoeffs.getSize<0>()) {
        throw LSST_EXCEPT(pex::exceptions::LengthError,
                          (boost::format("Coefficient matrices must be triangular, not trapezoidal: "
                                         " %d != %d ") %
                           _xCoeffs.getSize<0>() % _xCoeffs.getSize<1>())
                                  .str());
    }
}

PolynomialTransform() [2/3]

lsst::meas::astrom::PolynomialTransform::PolynomialTransform

(

PolynomialTransform const &

other

)

Copy constructor.

Coefficient arrays are deep-copied.

Definition at line 97 of file PolynomialTransform.cc.

        : _xCoeffs(ndarray::copy(other.getXCoeffs())),
          _yCoeffs(ndarray::copy(other.getYCoeffs())),
          _u(other._u.size()),
          _v(other._v.size()) {}

PolynomialTransform() [3/3]

lsst::meas::astrom::PolynomialTransform::PolynomialTransform

(

PolynomialTransform &&

other

)

Move constructor.

Coefficient arrays are moved.

Definition at line 103 of file PolynomialTransform.cc.

                                                                    : _xCoeffs(), _yCoeffs(), _u(), _v() {
    this->swap(other);
}

Member Function Documentation

convert() [1/3]

PolynomialTransform lsst::meas::astrom::PolynomialTransform::convert ( ScaledPolynomialTransform const & other )

static

Convert a ScaledPolynomialTransform to an equivalent PolynomialTransform.

Definition at line 36 of file PolynomialTransform.cc.

                                                                                        {
    return compose(scaled.getOutputScalingInverse(), compose(scaled.getPoly(), scaled.getInputScaling()));
}

convert() [2/3]

PolynomialTransform lsst::meas::astrom::PolynomialTransform::convert ( SipForwardTransform const & other )

static

Convert a SipForwardTransform to an equivalent PolynomialTransform.

Definition at line 40 of file PolynomialTransform.cc.

                                                                                 {
    PolynomialTransform poly = other.getPoly();
    // Adding 1 here accounts for the extra terms outside the sum in the SIP
    // transform definition (see SipForwardTransform docs) - note that you can
    // fold those terms into the sum by adding 1 from the A_10 and B_01 terms.
    poly._xCoeffs(1, 0) += 1;
    poly._yCoeffs(0, 1) += 1;
    return compose(other.getCdMatrix(),
                   compose(poly, geom::AffineTransform(geom::Point2D() - other.getPixelOrigin())));
}

convert() [3/3]

PolynomialTransform lsst::meas::astrom::PolynomialTransform::convert ( SipReverseTransform const & other )

static

Convert a SipReverseTransform to an equivalent PolynomialTransform.

Definition at line 51 of file PolynomialTransform.cc.

                                                                                 {
    PolynomialTransform poly = other.getPoly();
    // Account for the terms outside the sum in the SIP definition (see comment
    // earlier in the file for more explanation).
    poly._xCoeffs(1, 0) += 1;
    poly._yCoeffs(0, 1) += 1;
    return compose(geom::AffineTransform(geom::Extent2D(other.getPixelOrigin())),
                   compose(poly, other._cdInverse));
}

getOrder()

int lsst::meas::astrom::PolynomialTransform::getOrder ( ) const

inline

Return the order of the polynomials.

Definition at line 107 of file PolynomialTransform.h.

{ return _xCoeffs.getSize<0>() - 1; }

getXCoeffs()

ndarray::Array< double const, 2, 2 > lsst::meas::astrom::PolynomialTransform::getXCoeffs ( ) const

inline

2-D polynomial coefficients that compute the output x coordinate.

Indexing the result by [p][q] gives the coefficient of \(x_{\mathrm{in}}^p\,y_{\mathrm{in}}^q\).

Definition at line 115 of file PolynomialTransform.h.

{ return _xCoeffs.shallow(); }

getYCoeffs()

ndarray::Array< double const, 2, 2 > lsst::meas::astrom::PolynomialTransform::getYCoeffs ( ) const

inline

2-D polynomial coefficients that compute the output x coordinate.

Indexing the result by [p][q] gives the coefficient of \(x_{\mathrm{in}}^p\,y_{\mathrm{in}}^q\).

Definition at line 123 of file PolynomialTransform.h.

{ return _yCoeffs.shallow(); }

linearize()

geom::AffineTransform lsst::meas::astrom::PolynomialTransform::linearize

(

geom::Point2D const &

in

)

const

Return an approximate affine transform at the given point.

Definition at line 129 of file PolynomialTransform.cc.

                                                                              {
    double xu = 0.0, xv = 0.0, yu = 0.0, yv = 0.0, x = 0.0, y = 0.0;
    int const order = getOrder();
    detail::computePowers(_u, in.getX());
    detail::computePowers(_v, in.getY());
    for (int p = 0; p <= order; ++p) {
        for (int q = 0; q <= order; ++q) {
            if (p > 0) {
                xu += _xCoeffs(p, q) * p * _u[p - 1] * _v[q];
                yu += _yCoeffs(p, q) * p * _u[p - 1] * _v[q];
            }
            if (q > 0) {
                xv += _xCoeffs(p, q) * q * _u[p] * _v[q - 1];
                yv += _yCoeffs(p, q) * q * _u[p] * _v[q - 1];
            }
            x += _xCoeffs(p, q) * _u[p] * _v[q];
            y += _yCoeffs(p, q) * _u[p] * _v[q];
        }
    }
    geom::LinearTransform linear;
    linear.getMatrix()(0, 0) = xu;
    linear.getMatrix()(0, 1) = xv;
    linear.getMatrix()(1, 0) = yu;
    linear.getMatrix()(1, 1) = yv;
    geom::Point2D origin(x, y);
    return geom::AffineTransform(linear, origin - linear(in));
}

operator()()

geom::Point2D lsst::meas::astrom::PolynomialTransform::operator()

(

geom::Point2D const &

in

)

const

Apply the transform to a point.

Definition at line 157 of file PolynomialTransform.cc.

                                                                       {
    int const order = getOrder();
    detail::computePowers(_u, in.getX());
    detail::computePowers(_v, in.getY());
    double x = 0;
    double y = 0;
    for (int p = 0; p <= order; ++p) {
        for (int q = 0; q <= order; ++q) {
            x += _xCoeffs(p, q) * _u[p] * _v[q];
            y += _yCoeffs(p, q) * _u[p] * _v[q];
        }
    }
    return geom::Point2D(x, y);
}

operator=() [1/2]

PolynomialTransform & lsst::meas::astrom::PolynomialTransform::operator=

(

PolynomialTransform &&

other

)

Move constructor.

Coefficient arrays are moved.

Definition at line 115 of file PolynomialTransform.cc.

                                                                               {
    if (&other != this) {
        other.swap(*this);
    }
    return *this;
}

operator=() [2/2]

PolynomialTransform & lsst::meas::astrom::PolynomialTransform::operator=

(

PolynomialTransform const &

other

)

Copy assignment.

Coefficient arrays are deep-copied.

Definition at line 107 of file PolynomialTransform.cc.

                                                                                    {
    if (&other != this) {
        PolynomialTransform tmp(other);
        tmp.swap(*this);
    }
    return *this;
}

swap()

void lsst::meas::astrom::PolynomialTransform::swap

(

PolynomialTransform &

other

)

Lightweight swap.

Definition at line 122 of file PolynomialTransform.cc.

                                                         {
    _xCoeffs.swap(other._xCoeffs);
    _yCoeffs.swap(other._yCoeffs);
    _u.swap(other._u);
    _v.swap(other._v);
}

Friends And Related Symbol Documentation

compose() [1/3]

lsst::jointcal::compose ( AstrometryTransform const & , AstrometryTransform const &  )

related

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Note

If instead left is Identity, this method does the correct thing via AstrometryTransformIdentity::composeAndReduce().

compose [2/3]

PolynomialTransform compose ( geom::AffineTransform const & t1, PolynomialTransform const & t2 )

friend

Return a PolynomialTransform that is equivalent to the composition t1(t2())

The returned composition would be exact in ideal arithmetic, but may suffer from significant round-off error for high-order polynomials.

Definition at line 214 of file PolynomialTransform.cc.

                                                                                          {
    typedef geom::AffineTransform AT;
    PolynomialTransform result(t2.getOrder());
 
    result._xCoeffs.deep() = t2._xCoeffs * t1[AT::XX] + t2._yCoeffs * t1[AT::XY];
    result._yCoeffs.deep() = t2._xCoeffs * t1[AT::YX] + t2._yCoeffs * t1[AT::YY];
    result._xCoeffs(0, 0) += t1[AT::X];
    result._yCoeffs(0, 0) += t1[AT::Y];
    return result;
}

compose [3/3]

PolynomialTransform compose ( PolynomialTransform const & t1, geom::AffineTransform const & t2 )

friend

Return a PolynomialTransform that is equivalent to the composition t1(t2())

The returned composition would be exact in ideal arithmetic, but may suffer from significant round-off error for high-order polynomials.

Definition at line 225 of file PolynomialTransform.cc.

                                                                                          {
    typedef geom::AffineTransform AT;
    int const order = t1.getOrder();
    if (order < 1) {
        PolynomialTransform t1a(1);
        t1a._xCoeffs(0, 0) = t1._xCoeffs(0, 0);
        t1a._yCoeffs(0, 0) = t1._yCoeffs(0, 0);
        return compose(t1a, t2);
    }
    detail::BinomialMatrix binomial(order);
    // For each of these, (e.g.) a[n] == pow(a, n)
    auto const t2u = detail::computePowers(t2[AT::X], order);
    auto const t2v = detail::computePowers(t2[AT::Y], order);
    auto const t2uu = detail::computePowers(t2[AT::XX], order);
    auto const t2uv = detail::computePowers(t2[AT::XY], order);
    auto const t2vu = detail::computePowers(t2[AT::YX], order);
    auto const t2vv = detail::computePowers(t2[AT::YY], order);
    PolynomialTransform result(order);
    for (int p = 0; p <= order; ++p) {
        for (int m = 0; m <= p; ++m) {
            for (int j = 0; j <= m; ++j) {
                for (int q = 0; p + q <= order; ++q) {
                    for (int n = 0; n <= q; ++n) {
                        for (int k = 0; k <= n; ++k) {
                            double z = binomial(p, m) * t2u[p - m] * binomial(m, j) * t2uu[j] * t2uv[m - j] *
                                       binomial(q, n) * t2v[q - n] * binomial(n, k) * t2vu[k] * t2vv[n - k];
                            result._xCoeffs(j + k, m + n - j - k) += t1._xCoeffs(p, q) * z;
                            result._yCoeffs(j + k, m + n - j - k) += t1._yCoeffs(p, q) * z;
                        }  // k
                    }      // n
                }          // q
            }              // j
        }                  // m
    }                      // p
    return result;
}

ScaledPolynomialTransform

friend class ScaledPolynomialTransform

friend

Definition at line 143 of file PolynomialTransform.h.

ScaledPolynomialTransformFitter

friend class ScaledPolynomialTransformFitter

friend

Definition at line 140 of file PolynomialTransform.h.

SipForwardTransform

friend class SipForwardTransform

friend

Definition at line 141 of file PolynomialTransform.h.

SipReverseTransform

friend class SipReverseTransform

friend

Definition at line 142 of file PolynomialTransform.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_astrom/gff1a9f87cc+fa3a7a026e/include/lsst/meas/astrom/PolynomialTransform.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/jointcal/gbb8dafda3b+f991a0b59f/include/lsst/jointcal/AstrometryTransform.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_astrom/gff1a9f87cc+fa3a7a026e/src/PolynomialTransform.cc