LSST Applications g04e9c324dd+8c5ae1fdc5,g134cb467dc+b203dec576,g18429d2f64+358861cd2c,g199a45376c+0ba108daf9,g1fd858c14a+dd066899e3,g262e1987ae+ebfced1d55,g29ae962dfc+72fd90588e,g2cef7863aa+aef1011c0b,g35bb328faa+8c5ae1fdc5,g3fd5ace14f+b668f15bc5,g4595892280+3897dae354,g47891489e3+abcf9c3559,g4d44eb3520+fb4ddce128,g53246c7159+8c5ae1fdc5,g67b6fd64d1+abcf9c3559,g67fd3c3899+1f72b5a9f7,g74acd417e5+cb6b47f07b,g786e29fd12+668abc6043,g87389fa792+8856018cbb,g89139ef638+abcf9c3559,g8d7436a09f+bcf525d20c,g8ea07a8fe4+9f5ccc88ac,g90f42f885a+6054cc57f1,g97be763408+06f794da49,g9dd6db0277+1f72b5a9f7,ga681d05dcb+7e36ad54cd,gabf8522325+735880ea63,gac2eed3f23+abcf9c3559,gb89ab40317+abcf9c3559,gbf99507273+8c5ae1fdc5,gd8ff7fe66e+1f72b5a9f7,gdab6d2f7ff+cb6b47f07b,gdc713202bf+1f72b5a9f7,gdfd2d52018+8225f2b331,ge365c994fd+375fc21c71,ge410e46f29+abcf9c3559,geaed405ab2+562b3308c0,gf9a733ac38+8c5ae1fdc5,w.2025.35
LSST Data Management Base Package
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Friends | Related Symbols | List of all members
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.

76 : _xCoeffs(ndarray::copy(xCoeffs)),
77 _yCoeffs(ndarray::copy(yCoeffs)),
78 _u(_xCoeffs.getSize<0>()),
79 _v(_xCoeffs.getSize<0>()) {
80 if (xCoeffs.getShape() != yCoeffs.getShape()) {
81 throw LSST_EXCEPT(
82 pex::exceptions::LengthError,
83 (boost::format("X and Y coefficient matrices must have the same shape: "
84 " (%d,%d) != (%d,%d)") %
85 xCoeffs.getSize<0>() % xCoeffs.getSize<1>() % yCoeffs.getSize<0>() % yCoeffs.getSize<1>())
86 .str());
87 }
88 if (_xCoeffs.getSize<1>() != _xCoeffs.getSize<0>()) {
89 throw LSST_EXCEPT(pex::exceptions::LengthError,
90 (boost::format("Coefficient matrices must be triangular, not trapezoidal: "
91 " %d != %d ") %
92 _xCoeffs.getSize<0>() % _xCoeffs.getSize<1>())
93 .str());
94 }
95}
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition Exception.h:48

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

98 : _xCoeffs(ndarray::copy(other.getXCoeffs())),
99 _yCoeffs(ndarray::copy(other.getYCoeffs())),
100 _u(other._u.size()),
101 _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.

103 : _xCoeffs(), _yCoeffs(), _u(), _v() {
104 this->swap(other);
105}
lsst::meas::astrom::PolynomialTransform::swap
void swap(PolynomialTransform &other)
Lightweight swap.
Definition PolynomialTransform.cc:122

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.

36 {
37 return compose(scaled.getOutputScalingInverse(), compose(scaled.getPoly(), scaled.getInputScaling()));
38}
lsst::meas::astrom::PolynomialTransform::compose
friend PolynomialTransform compose(geom::AffineTransform const &t1, PolynomialTransform const &t2)
Return a PolynomialTransform that is equivalent to the composition t1(t2())
Definition PolynomialTransform.cc:214

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

40 {
41 PolynomialTransform poly = other.getPoly();
42 // Adding 1 here accounts for the extra terms outside the sum in the SIP
43 // transform definition (see SipForwardTransform docs) - note that you can
44 // fold those terms into the sum by adding 1 from the A_10 and B_01 terms.
45 poly._xCoeffs(1, 0) += 1;
46 poly._yCoeffs(0, 1) += 1;
47 return compose(other.getCdMatrix(),
48 compose(poly, geom::AffineTransform(geom::Point2D() - other.getPixelOrigin())));
49}
lsst::meas::astrom::PolynomialTransform::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.
Definition PolynomialTransform.cc:74
lsst::geom::Point2D
Point< double, 2 > Point2D
Definition Point.h:324

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

51 {
52 PolynomialTransform poly = other.getPoly();
53 // Account for the terms outside the sum in the SIP definition (see comment
54 // earlier in the file for more explanation).
55 poly._xCoeffs(1, 0) += 1;
56 poly._yCoeffs(0, 1) += 1;
57 return compose(geom::AffineTransform(geom::Extent2D(other.getPixelOrigin())),
58 compose(poly, other._cdInverse));
59}
lsst::geom::Extent2D
Extent< double, 2 > Extent2D
Definition Extent.h:400

◆ getOrder()

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

Return the order of the polynomials.

Definition at line 107 of file PolynomialTransform.h.

107{ 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.

115{ 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.

123{ 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.

129 {
130 double xu = 0.0, xv = 0.0, yu = 0.0, yv = 0.0, x = 0.0, y = 0.0;
131 int const order = getOrder();
132 detail::computePowers(_u, in.getX());
133 detail::computePowers(_v, in.getY());
134 for (int p = 0; p <= order; ++p) {
135 for (int q = 0; q <= order; ++q) {
136 if (p > 0) {
137 xu += _xCoeffs(p, q) * p * _u[p - 1] * _v[q];
138 yu += _yCoeffs(p, q) * p * _u[p - 1] * _v[q];
139 }
140 if (q > 0) {
141 xv += _xCoeffs(p, q) * q * _u[p] * _v[q - 1];
142 yv += _yCoeffs(p, q) * q * _u[p] * _v[q - 1];
143 }
144 x += _xCoeffs(p, q) * _u[p] * _v[q];
145 y += _yCoeffs(p, q) * _u[p] * _v[q];
146 }
147 }
148 geom::LinearTransform linear;
149 linear.getMatrix()(0, 0) = xu;
150 linear.getMatrix()(0, 1) = xv;
151 linear.getMatrix()(1, 0) = yu;
152 linear.getMatrix()(1, 1) = yv;
153 geom::Point2D origin(x, y);
154 return geom::AffineTransform(linear, origin - linear(in));
155}
lsst::meas::astrom::PolynomialTransform::getOrder
int getOrder() const
Return the order of the polynomials.
Definition PolynomialTransform.h:107
lsst::gauss2d::fit::InterpType::linear
@ linear
Linear interpolation.
Definition interpolation.h:7
lsst::meas::astrom::detail::computePowers
void computePowers(Eigen::VectorXd &r, double x)
Fill an array with integer powers of x, so .
Definition polynomialUtils.cc:33

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

157 {
158 int const order = getOrder();
159 detail::computePowers(_u, in.getX());
160 detail::computePowers(_v, in.getY());
161 double x = 0;
162 double y = 0;
163 for (int p = 0; p <= order; ++p) {
164 for (int q = 0; q <= order; ++q) {
165 x += _xCoeffs(p, q) * _u[p] * _v[q];
166 y += _yCoeffs(p, q) * _u[p] * _v[q];
167 }
168 }
169 return geom::Point2D(x, y);
170}

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

115 {
116 if (&other != this) {
117 other.swap(*this);
118 }
119 return *this;
120}

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

107 {
108 if (&other != this) {
109 PolynomialTransform tmp(other);
110 tmp.swap(*this);
111 }
112 return *this;
113}

◆ swap()

void lsst::meas::astrom::PolynomialTransform::swap ( PolynomialTransform & other)

Lightweight swap.

Definition at line 122 of file PolynomialTransform.cc.

122 {
123 _xCoeffs.swap(other._xCoeffs);
124 _yCoeffs.swap(other._yCoeffs);
125 _u.swap(other._u);
126 _v.swap(other._v);
127}

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.

214 {
215 typedef geom::AffineTransform AT;
216 PolynomialTransform result(t2.getOrder());
217
218 result._xCoeffs.deep() = t2._xCoeffs * t1[AT::XX] + t2._yCoeffs * t1[AT::XY];
219 result._yCoeffs.deep() = t2._xCoeffs * t1[AT::YX] + t2._yCoeffs * t1[AT::YY];
220 result._xCoeffs(0, 0) += t1[AT::X];
221 result._yCoeffs(0, 0) += t1[AT::Y];
222 return result;
223}

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

225 {
226 typedef geom::AffineTransform AT;
227 int const order = t1.getOrder();
228 if (order < 1) {
229 PolynomialTransform t1a(1);
230 t1a._xCoeffs(0, 0) = t1._xCoeffs(0, 0);
231 t1a._yCoeffs(0, 0) = t1._yCoeffs(0, 0);
232 return compose(t1a, t2);
233 }
234 detail::BinomialMatrix binomial(order);
235 // For each of these, (e.g.) a[n] == pow(a, n)
236 auto const t2u = detail::computePowers(t2[AT::X], order);
237 auto const t2v = detail::computePowers(t2[AT::Y], order);
238 auto const t2uu = detail::computePowers(t2[AT::XX], order);
239 auto const t2uv = detail::computePowers(t2[AT::XY], order);
240 auto const t2vu = detail::computePowers(t2[AT::YX], order);
241 auto const t2vv = detail::computePowers(t2[AT::YY], order);
242 PolynomialTransform result(order);
243 for (int p = 0; p <= order; ++p) {
244 for (int m = 0; m <= p; ++m) {
245 for (int j = 0; j <= m; ++j) {
246 for (int q = 0; p + q <= order; ++q) {
247 for (int n = 0; n <= q; ++n) {
248 for (int k = 0; k <= n; ++k) {
249 double z = binomial(p, m) * t2u[p - m] * binomial(m, j) * t2uu[j] * t2uv[m - j] *
250 binomial(q, n) * t2v[q - n] * binomial(n, k) * t2vu[k] * t2vv[n - k];
251 result._xCoeffs(j + k, m + n - j - k) += t1._xCoeffs(p, q) * z;
252 result._yCoeffs(j + k, m + n - j - k) += t1._yCoeffs(p, q) * z;
253 } // k
254 } // n
255 } // q
256 } // j
257 } // m
258 } // p
259 return result;
260}

◆ 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:
Generated on Wed Sep 3 2025 07:01:42 for LSST Applications by doxygen 1.13.2