LSSTApplications  21.0.0+1b62c9342b,21.0.0+45a059f35e,21.0.0-1-ga51b5d4+ceb9cf20a3,21.0.0-17-gf9a0284+9e5b25d042,21.0.0-2-g103fe59+513edb8842,21.0.0-2-g1367e85+d9bb5204cb,21.0.0-2-g2909d54+45a059f35e,21.0.0-2-g45278ab+1b62c9342b,21.0.0-2-g4bc9b9f+36532ac5d2,21.0.0-2-g5242d73+d9bb5204cb,21.0.0-2-g54e2caa+0b4b33a26b,21.0.0-2-g66bcc37+0525a04256,21.0.0-2-g7f82c8f+8938dec807,21.0.0-2-g8dde007+7bfb5851c8,21.0.0-2-g8f08a60+73884b2cf5,21.0.0-2-g973f35b+44678ca34c,21.0.0-2-ga326454+8938dec807,21.0.0-2-ga63a54e+682c8ce20e,21.0.0-2-ga885a99+9a92674037,21.0.0-2-gc738bc1+5ce50b2a03,21.0.0-2-gde069b7+5a8f2956b8,21.0.0-2-ge17e5af+d9bb5204cb,21.0.0-2-ge712728+d5c34dc911,21.0.0-2-gecfae73+8bdf007ced,21.0.0-2-gfc62afb+d9bb5204cb,21.0.0-21-g006371a9+5abec3504c,21.0.0-3-g4c5b185+4e2de95c30,21.0.0-3-g6d51c4a+0525a04256,21.0.0-3-gaa929c8+fca53d2b73,21.0.0-3-gd222c45+afc8332dbe,21.0.0-3-gd5de2f2+0525a04256,21.0.0-4-g3300ddd+1b62c9342b,21.0.0-4-g8a80011+23661db33a,21.0.0-5-gb7080ec+ee9551b7be,21.0.0-5-gcff38f6+e51f0852ce,21.0.0-6-gd3283ba+fca53d2b73,21.0.0-8-g19111d86+898b2b281f,21.0.0-8-gd9c33f4a0+b58bb1f4d6,w.2021.03
LSSTDataManagementBasePackage
Public Member Functions | Static Public Member Functions | Friends | Related Functions | 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. More...
 
 PolynomialTransform (PolynomialTransform const &other)
 Copy constructor. More...
 
 PolynomialTransform (PolynomialTransform &&other)
 Move constructor. More...
 
PolynomialTransformoperator= (PolynomialTransform const &other)
 Copy assignment. More...
 
PolynomialTransformoperator= (PolynomialTransform &&other)
 Move constructor. More...
 
void swap (PolynomialTransform &other)
 Lightweight swap. More...
 
int getOrder () const
 Return the order of the polynomials. More...
 
ndarray::Array< double const, 2, 2 > getXCoeffs () const
 2-D polynomial coefficients that compute the output x coordinate. More...
 
ndarray::Array< double const, 2, 2 > getYCoeffs () const
 2-D polynomial coefficients that compute the output x coordinate. More...
 
geom::AffineTransform linearize (geom::Point2D const &in) const
 Return an approximate affine transform at the given point. More...
 
geom::Point2D operator() (geom::Point2D const &in) const
 Apply the transform to a point. More...
 

Static Public Member Functions

static PolynomialTransform convert (ScaledPolynomialTransform const &other)
 Convert a ScaledPolynomialTransform to an equivalent PolynomialTransform. More...
 
static PolynomialTransform convert (SipForwardTransform const &other)
 Convert a SipForwardTransform to an equivalent PolynomialTransform. More...
 
static PolynomialTransform convert (SipReverseTransform const &other)
 Convert a SipReverseTransform to an equivalent PolynomialTransform. More...
 

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()) More...
 
PolynomialTransform compose (PolynomialTransform const &t1, geom::AffineTransform const &t2)
 Return a PolynomialTransform that is equivalent to the composition t1(t2()) More...
 

Related Functions

(Note that these are not member functions.)

 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 }

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

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 }

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

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

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

◆ 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) {
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 Function 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);
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:
y
int y
Definition: SpanSet.cc:49
lsst::meas::astrom::PolynomialTransform::getOrder
int getOrder() const
Return the order of the polynomials.
Definition: PolynomialTransform.h:107
lsst::geom::LinearTransform
A 2D linear coordinate transformation.
Definition: LinearTransform.h:69
lsst.pex.config.history.format
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174
lsst::geom::Point2D
Point< double, 2 > Point2D
Definition: Point.h:324
lsst::afw::image::X
@ X
Definition: ImageUtils.h:36
lsst::geom::AffineTransform
An affine coordinate transformation consisting of a linear transformation and an offset.
Definition: AffineTransform.h:75
z
double z
Definition: Match.cc:44
x
double x
Definition: ChebyshevBoundedField.cc:277
other
ItemVariant const * other
Definition: Schema.cc:56
lsst::afw::image::Y
@ Y
Definition: ImageUtils.h:36
result
py::object result
Definition: _schema.cc:429
lsst::geom::LinearTransform::getMatrix
Matrix const & getMatrix() const noexcept
Definition: LinearTransform.h:151
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
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::polynomials
Low-level polynomials (including special polynomials) in C++.
Definition: Basis1d.h:26
lsst::geom::Point< double, 2 >
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
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
lsst::geom::Extent< double, 2 >
lsst::meas::astrom::PolynomialTransform::swap
void swap(PolynomialTransform &other)
Lightweight swap.
Definition: PolynomialTransform.cc:122
m
int m
Definition: SpanSet.cc:49