#include <PolyMap.h>
Public Member Functions | |
PolyMap (ndarray::Array< double, 2, 2 > const &coeff_f, ndarray::Array< double, 2, 2 > const &coeff_i, std::string const &options="IterInverse=0") | |
PolyMap (ndarray::Array< double, 2, 2 > const &coeff_f, int nout, std::string const &options="IterInverse=0") | |
PolyMap (PolyMap const &)=delete | |
PolyMap (PolyMap &&)=default | |
PolyMap & | operator= (PolyMap const &)=delete |
PolyMap & | operator= (PolyMap &&)=default |
std::shared_ptr< PolyMap > | copy () const |
Return a deep copy of this object. | |
bool | getIterInverse () const |
Get IterInverse: does this provide an iterative inverse transformation? | |
int | getNIterInverse () const |
Get NIterInverse: maximum number of iterations for iterative inverse. | |
double | getTolInverse () const |
Get TolInverse: target relative error for iterative inverse. | |
PolyMap | polyTran (bool forward, double acc, double maxacc, int maxorder, std::vector< double > const &lbnd, std::vector< double > const &ubnd) const |
![]() | |
Mapping (Mapping const &)=delete | |
Mapping (Mapping &&)=default | |
Mapping & | operator= (Mapping const &)=delete |
Mapping & | operator= (Mapping &&)=default |
std::shared_ptr< Mapping > | copy () const |
Return a deep copy of this object. | |
int | getNIn () const |
int | getNOut () const |
bool | getIsSimple () const |
bool | isInverted () const |
bool | getIsLinear () const |
bool | getReport () const |
bool | hasForward () const |
bool | hasInverse () const |
std::shared_ptr< Mapping > | getInverse () const |
Array2D | linearApprox (PointD const &lbnd, PointD const &ubnd, double tol) const |
SeriesMap | then (Mapping const &next) const |
ParallelMap | under (Mapping const &next) const |
double | rate (PointD const &at, int ax1, int ax2) const |
void | setReport (bool report) |
std::shared_ptr< Mapping > | simplify () const |
void | applyForward (ConstArray2D const &from, Array2D const &to) const |
Array2D | applyForward (ConstArray2D const &from) const |
std::vector< double > | applyForward (std::vector< double > const &from) const |
void | applyInverse (ConstArray2D const &from, Array2D const &to) const |
Array2D | applyInverse (ConstArray2D const &from) const |
std::vector< double > | applyInverse (std::vector< double > const &from) const |
void | tranGridForward (PointI const &lbnd, PointI const &ubnd, double tol, int maxpix, Array2D const &to) const |
Array2D | tranGridForward (PointI const &lbnd, PointI const &ubnd, double tol, int maxpix, int nPts) const |
void | tranGridInverse (PointI const &lbnd, PointI const &ubnd, double tol, int maxpix, Array2D const &to) const |
Array2D | tranGridInverse (PointI const &lbnd, PointI const &ubnd, double tol, int maxpix, int nPts) const |
![]() | |
Object (Object const &)=delete | |
Object (Object &&)=default | |
Object & | operator= (Object const &)=delete |
Object & | operator= (Object &&)=default |
bool | operator== (Object const &rhs) const |
bool | operator!= (Object const &rhs) const |
std::shared_ptr< Object > | copy () const |
Return a deep copy of this object. | |
void | clear (std::string const &attrib) |
bool | hasAttribute (std::string const &attrib) const |
std::string | getClassName () const |
std::string | getID () const |
Get ID: object identification string that is not copied. | |
std::string | getIdent () const |
Get Ident: object identification string that is copied. | |
int | getNObject () const |
int | getObjSize () const |
Get ObjSize: the in-memory size of the AST object in bytes. | |
int | getRefCount () const |
bool | getUseDefs () const |
Get UseDefs: allow use of default values for Object attributes? | |
void | lock (bool wait) |
bool | same (Object const &other) const |
void | setID (std::string const &id) |
Set ID: object identification string that is not copied. | |
void | setIdent (std::string const &ident) |
Set Ident: object identification string that is copied. | |
void | setUseDefs (bool usedefs) |
Set UseDefs: allow use of default values for Object attributes? | |
void | show (std::ostream &os, bool showComments=true) const |
std::string | show (bool showComments=true) const |
bool | test (std::string const &attrib) |
void | unlock (bool report=false) |
AstObject const * | getRawPtr () const |
AstObject * | getRawPtr () |
Protected Member Functions | |
virtual std::shared_ptr< Object > | copyPolymorphic () const override |
PolyMap (AstPolyMap *map) | |
Construct a PolyMap from an raw AST pointer. | |
![]() | |
Mapping (AstMapping *rawMap) | |
template<typename Class > | |
std::shared_ptr< Class > | decompose (int i, bool copy) const |
![]() | |
Object (AstObject *object) | |
template<typename T , typename AstT > | |
std::shared_ptr< T > | copyImpl () const |
bool | getB (std::string const &attrib) const |
std::string const | getC (std::string const &attrib) const |
double | getD (std::string const &attrib) const |
float | getF (std::string const &attrib) const |
int | getI (std::string const &attrib) const |
long int | getL (std::string const &attrib) const |
void | set (std::string const &setting) |
void | setB (std::string const &attrib, bool value) |
void | setC (std::string const &attrib, std::string const &value) |
void | setD (std::string const &attrib, double value) |
void | setF (std::string const &attrib, float value) |
void | setI (std::string const &attrib, int value) |
void | setL (std::string const &attrib, long int value) |
Friends | |
class | Object |
Additional Inherited Members | |
![]() | |
using | ObjectPtr = std::unique_ptr< AstObject, Deleter > |
unique pointer holding an AST raw pointer | |
![]() | |
static std::shared_ptr< Object > | fromString (std::string const &str) |
template<typename Class > | |
static std::shared_ptr< Class > | fromAstObject (AstObject *rawObj, bool copy) |
![]() | |
template<typename ShimT , typename AstT > | |
static std::shared_ptr< ShimT > | makeShim (AstObject *p) |
PolyMap is a Mapping which performs a general polynomial transformation. Each output coordinate is a polynomial function of all the input coordinates. The coefficients are specified separately for each output coordinate. The forward and inverse transformations are defined independantly by separate sets of coefficients. If no inverse transformation is supplied, an iterative method can be used to evaluate the inverse based only on the forward transformation.
All those of Mapping plus:
|
inlineexplicit |
Construct a PolyMap with specified forward and/or inverse transforms.
The two sets of coefficients are independent of each other: the inverse transform need not undo the forward transform.
[in] | coeff_f | A (2 + nin) x ncoeff_f matrix of coefficients describing the forward transformation. If coeff_f is empty then no forward transformation is provided. |
[in] | coeff_i | A (2 + nout) x ncoeff_i` matrix of coefficients for the inverse transformation. If coeff_i is empty then no inverse transformation is provided unless you specify suitable options to request an iterative inverse; see the other constructor for details. |
[in] | options | Comma-separated list of attribute assignments. |
std::invalid_argument | if neither transform is specified (coeff_f and coeff_i are both empty) |
The coefficients describing a forward transformation are specified as an ncoeff_f x (2 + nin)
matrix, where ncoeff_f
is the number of coefficients for the forward direction, and each coefficient is described by 2 + nin
contiguous values, as follows:
For instance, if the PolyMap has 3 inputs and 2 outputs, each row consisting of 5 elements, and the row (1.2, 2, 6, 3, 0)
describes a coefficient that increments output 2 as follows: out2 += 1.2 * in1^6 * in2^3 * in3^0
and the row (-1.5, 1, 0, 0, 0)
describes a coefficient that increments output 2 with a constant value of -1.5 (since all powers are 0): out1 += -1.5 * in1^0 * in2^0 * in3^0
Each final output coordinate value is the sum of the terms described by the ncoeff_f
columns in the supplied array. If no coefficients increment a given output then it will be set to 0.
The coefficients describing the inverse transformation work the same way, but of course the matrix is of size ncoeff_i x (2 + nout)
, where ncoeff_i
is the number of coefficients for the inverse transformation.
|
inlineexplicit |
Construct a PolyMap with only the forward transform specified.
If the polynomial is invertible and you want an inverse you have two choices: either specify suitable options to request an iterative inverse, or call polyTran to fit an inverse. Both have advantages:
[in] | coeff_f | A (2 + nin) x ncoeff_f matrix of coefficients describing the forward transformation. If coeff_f is empty then no forward transformation is provided. |
[in] | nout | Number of output coordinates. |
[in] | options | Comma-separated list of attribute assignments. Useful attributes include: IterInverse, NIterInverse and TolInverse. |
std::invalid_argument | if the forward transform is not specified (coeff_f is empty) |
|
inlineoverrideprotectedvirtual |
Return a deep copy of this object. This is called by copy.
Each subclass must override this method. The standard implementation is: ``` return copyImpl<astshim_class, ast_class>(); ``` for example Frame implements this as: ``` return copyImpl<Frame, AstFrame>(); ```
Reimplemented from ast::Mapping.
PolyMap ast::PolyMap::polyTran | ( | bool | forward, |
double | acc, | ||
double | maxacc, | ||
int | maxorder, | ||
std::vector< double > const & | lbnd, | ||
std::vector< double > const & | ubnd | ||
) | const |
This function creates a new PolyMap which is a copy of this one, in which a specified transformation (forward or inverse) has been replaced by a new polynomial transformation. The coefficients of the new transformation are estimated by sampling the other transformation and performing a least squares polynomial fit in the opposite direction to the sampled positions and values.
This method can only be used on (1-input,1-output) or (2-input, 2-output) PolyMaps.
The transformation to create is specified by the forward
parameter. In what follows "X" refers to the inputs of the PolyMap, and "Y" to the outputs of the PolyMap. The forward transformation transforms input values (X) into output values (Y), and the inverse transformation transforms output values (Y) into input values (X). Within a PolyMap, each transformation is represented by an independent set of polynomials, P_f or P_i: Y=P_f(X) for the forward transformation and X=P_i(Y) for the inverse transformation.
The forward
parameter specifies the transformation to be replaced. If it is false, a new forward transformation is created by first finding the input values (X) using the inverse transformation (which must be available) at a regular grid of points (Y) covering a rectangular region of the PolyMap's output space. The coefficients of the required forward polynomial, Y=P_f(X), are chosen in order to minimise the sum of the squared residuals between the sampled values of Y and P_f(X).
If forward
is false (probably the most likely case), a new inverse transformation is created by first finding the output values (Y) using the forward transformation (which must be available) at a regular grid of points (X) covering a rectangular region of the PolyMap's input space. The coefficients of the required inverse polynomial, X=P_i(Y), are chosen in order to minimise the sum of the squared residuals between the sampled values of X and P_i(Y).
This fitting process is performed repeatedly with increasing polynomial orders (starting with linear) until the target accuracy is achieved, or a specified maximum order is reached. If the target accuracy cannot be achieved even with this maximum-order polynomial, the best fitting maximum-order polynomial is returned so long as its accuracy is better than "maxacc". If it is not, an error is reported.
[in] | forward | If true the forward transformation is replaced. Otherwise the inverse transformation is replaced. |
[in] | acc | The target accuracy, expressed as a geodesic distance within the PolyMap's input space (if forward is false) or output space (if forward is true). |
[in] | maxacc | The maximum allowed accuracy for an acceptable polynomial, expressed as a geodesic distance within the PolyMap's input space (if forward is false) or output space (if forward is true). |
[in] | maxorder | The maximum allowed polynomial order. This is one more than the maximum power of either input axis. So for instance, a value of 3 refers to a quadratic polynomial. Note, cross terms with total powers greater than or equal to maxorder are not inlcuded in the fit. So the maximum number of terms in each of the fitted polynomials is maxorder*(maxorder + 1)/2. |
[in] | lbnd | A vector holding the lower bounds of a rectangular region within the PolyMap's input space (if forward is false) or output space (if forward is true). The new polynomial will be evaluated over this rectangle. The length should equal getNIn() or getNOut(), depending on forward . |
[in] | ubnd | A vector holding the upper bounds of a rectangular region within the PolyMap's input space (if forward is false) or output space (if forward is true). The new polynomial will be evaluated over this rectangle. The length should equal getNIn() or getNOut(), depending on forward . |