|
virtual | ~Mapping () |
|
| Mapping (Mapping const &)=default |
| Copy constructor: make a deep copy. More...
|
|
| 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. More...
|
|
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 > | inverted () 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 > | simplified () 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 |
|
virtual | ~Object () |
|
| Object (Object const &object) |
| Copy constructor: make a deep copy. More...
|
|
| 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. More...
|
|
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. More...
|
|
std::string | getIdent () const |
| Get Ident: object identification string that is copied. More...
|
|
int | getNObject () const |
|
int | getObjSize () const |
| Get ObjSize: the in-memory size of the AST object in bytes. More...
|
|
int | getRefCount () const |
|
bool | getUseDefs () const |
| Get UseDefs: allow use of default values for Object attributes? More...
|
|
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. More...
|
|
void | setIdent (std::string const &ident) |
| Set Ident: object identification string that is copied. More...
|
|
void | setUseDefs (bool usedefs) |
| Set UseDefs: allow use of default values for Object attributes? More...
|
|
void | show (std::ostream &os, bool showComments=true) const |
|
std::string | show (bool showComments=true) const |
|
bool | test (std::string const &attrib) const |
|
void | unlock (bool report=false) |
|
AstObject const * | getRawPtr () const |
|
AstObject * | getRawPtr () |
|
|
| Mapping (AstMapping *rawMap) |
|
virtual std::shared_ptr< Object > | copyPolymorphic () const override |
|
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) |
|
|
using | ObjectPtr = std::unique_ptr< AstObject, Deleter > |
| unique pointer holding an AST raw pointer More...
|
|
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) |
|
An abstract base class for objects which transform one set of coordinates to another.
Mapping is used to describe the relationship which exists between two different coordinate systems and to implement operations which make use of this (such as transforming coordinates and resampling grids of data).
Attributes
In addition to those attributes common to Object, Mapping also has the following attributes:
virtual std::shared_ptr<Object> ast::Mapping::copyPolymorphic |
( |
| ) |
const |
|
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>();
Implements ast::Object.
Reimplemented in ast::ZoomMap, ast::WinMap, ast::WcsMap, ast::UnitNormMap, ast::UnitMap, ast::TranMap, ast::TimeMap, ast::TimeFrame, ast::SphMap, ast::SpecFrame, ast::SlaMap, ast::SkyFrame, ast::ShiftMap, ast::SeriesMap, ast::RateMap, ast::PolyMap, ast::PermMap, ast::PcdMap, ast::ParallelMap, ast::NormMap, ast::MatrixMap, ast::MathMap, ast::LutMap, ast::FrameSet, ast::FrameDict, ast::Frame, ast::CmpMap, ast::CmpFrame, and ast::ChebyMap.
std::shared_ptr< Mapping > ast::Mapping::inverted |
( |
| ) |
const |
Get an inverse mapping
An inverse mapping is a deep copy of a mapping whose Invert attribute has been toggled, as indicated by isInverted. This swaps the meaning of "input" and "output", and of "forward" and "inverse". Thus it swaps the behavior of applyForward and applyInverse, getNIn and getNOut, hasForward and hasInverse and so on.
Note that the inverse mapping contains exactly the same model coefficients as the original, but they are used by applyInverse instead of applyForward. Thus for example if a ZoomMap has a zoom factor of 4.0 then its inverse also reports a zoom factor of 4.0 (despite behaving like an uninverted ZoomMap with zoom factor of 0.25).
std::shared_ptr<Mapping> ast::Mapping::simplified |
( |
| ) |
const |
|
inline |
Return a simplied version of the mapping (which may be a compound Mapping such as a CmpMap).
Simplification eliminates redundant computational steps and merges separate steps which can be performed more efficiently in a single operation. As a simple example, a Mapping which multiplied coordinates by 5, and then multiplied the result by 10, could be simplified to a single step which multiplied by 50. Similarly, a Mapping which multiplied by 5, and then divided by 5, could be reduced to a simple copying operation.
This function should typically be applied to Mappings which have undergone substantial processing or have been formed by merging other Mappings. It is of potential benefit, for example, in reducing execution time if applied before using a Mapping to transform a large number of coordinates.
- Note
- If the supplied Mapping is a FrameSet, the returned Mapping will be a deep copy of the supplied FrameSet in which all the inter-Frame Mappings have been simplified. Mappings that have a set value for their ref Object_Ident "Ident" attribute are unchanged by simplification. This is so that their individual identity is preserved. This restriction does not apply to the simplification of Frames. The returned mapping is always independent of the original (a deep copy), unlike astSimplify.
void ast::Mapping::tranGridForward |
( |
PointI const & |
lbnd, |
|
|
PointI const & |
ubnd, |
|
|
double |
tol, |
|
|
int |
maxpix, |
|
|
Array2D const & |
to |
|
) |
| const |
|
inline |
Transform a grid of points in the forward direction
- Parameters
-
[in] | lbnd | The coordinates of the centre of the first pixel in the input grid along each dimension, size = nIn |
[in] | ubnd | The coordinates of the centre of the last pixel in the input grid along each dimension, size = nIn |
[in] | tol | The maximum tolerable geometrical distortion which may be introduced as a result of approximating non-linear Mappings by a set of piece-wise linear transformations. This should be expressed as a displacement within the output coordinate system of the Mapping. |
If piece-wise linear approximation is not required, a value of zero may be given. This will ensure that the Mapping is used without any approximation, but may increase execution time.
If the value is too high, discontinuities between the linear approximations used in adjacent panel will be higher. If this is a problem, reduce the tolerance value used.
- Parameters
-
[in] | maxpix | A value which specifies an initial scale size (in input grid points) for the adaptive algorithm which approximates non-linear Mappings with piece-wise linear transformations. Normally, this should be a large value (larger than any dimension of the region of the input grid being used). In this case, a first attempt to approximate the Mapping by a linear transformation will be made over the entire input region. If a smaller value is used, the input region will first be divided into sub-regions whose size does not exceed " maxpix" grid points in any dimension. Only at this point will attempts at approximation commence. This value may occasionally be useful in preventing false convergence of the adaptive algorithm in cases where the Mapping appears approximately linear on large scales, but has irregularities (e.g. holes) on smaller scales. A value of, say, 50 to 100 grid points can also be employed as a safeguard in general-purpose software, since the effect on performance is minimal. If too small a value is given, it will have the effect of inhibiting linear approximation altogether (equivalent to setting " tol" to zero). Although this may degrade performance, accurate results will still be obtained. |
[in] | to | Computed points, with dimensions (nPts, nOut), where nPts the desired number of points |
Return a parallel compound mapping containing shallow copies of the original
The resulting mapping has getNIn() + next.getNIn()
inputs and getNOut() + next.getNOut()
outputs. The first getNIn()
axes of input are transformed by this mapping, producing the first getNOut()
axes of output. The remaining axes of input are processed by next
, resulting in the remaining axes of output.
The name comes the way vectors are sometimes shown for matrix multiplication: vertically, with the first axis at the bottom and the last axis at the top.
- Parameters
-
[in] | next | the mapping that processes the final next.getNin() axes of input to produce the final next.getNout() axes of output. |
- Warning
- The contained mappings are shallow copies (just like AST); if you want deep copies then make them manually.