LSSTApplications: ast::FrameDict Class Reference

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getAllDomains()

std::set< std::string > ast::FrameDict::getAllDomains ( ) const

Get the domain names for all contained Frames (excluding frames with empty or defaulted domain names).

Definition at line 45 of file FrameDict.cc.

                                                  {
     std::set<std::string> domains;
     for (auto const &item : _domainIndexDict) {
         domains.emplace(item.first);
     }
     return domains;
 }

◆ getAllVariants()

std::string ast::FrameSet::getAllVariants ( ) const

inlineinherited

Get AllVariants: a list of all variant mappings stored with the current Frame.

Definition at line 243 of file FrameSet.h.

243 { return getC("AllVariants"); }

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getB()

bool ast::Object::getB ( std::string const & attrib ) const

inlineprotectedinherited

Get the value of an attribute as a bool.

If possible, the attribute value is converted to the type you request.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 348 of file Object.h.

                                              {
         bool val = astGetI(getRawPtr(), attrib.c_str());
         assertOK();
         return val;
     }

◆ getBase()

int ast::FrameSet::getBase ( ) const

inlineinherited

Get Base: index of base Frame.

Definition at line 248 of file FrameSet.h.

248 { return getI("Base"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getBottom()

double ast::Frame::getBottom ( int axis ) const

inlineinherited

Get Bottom for one axis: the lowest axis value to display.

Definition at line 807 of file Frame.h.

807 { return getD(detail::formatAxisAttr("Bottom", axis)); }

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

ast::detail::getClassName

double getD(std::string const &attrib) const

Get the value of an attribute as a double.

Definition: Object.h:374

◆ getC()

std::string const ast::Object::getC ( std::string const & attrib ) const

inlineprotectedinherited

Get the value of an attribute as a string.

If possible, the attribute value is converted to the type you request.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 361 of file Object.h.

                                                         {
         char const *rawval = astGetC(getRawPtr(), attrib.c_str());
         assertOK();
         return std::string(rawval);
     }

◆ getClassName()

std::string ast::Object::getClassName ( ) const

inlineinherited

Get Class: the name of the class (e.g.

ZoomMap)

Note: if AST returns "CmpMap" then the name will be changed to "SeriesMap" or "ParallelMap", as appropriate.

Definition at line 139 of file Object.h.

139 { return detail::getClassName(getRawPtr()); }

ast::Object::getRawPtr

AstObject const * getRawPtr() const

Get the raw AST pointer.

Definition: Object.h:292

std::string getClassName(AstObject const *rawObj)

Get the AST class name, changing CmpMap to SeriesMap or ParallelMap as appropriate.

Definition: utils.cc:37

◆ getCurrent()

int ast::FrameSet::getCurrent ( ) const

inlineinherited

Get Current: index of current Frame, starting from 1.

Definition at line 253 of file FrameSet.h.

253 { return getI("Current"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getD()

double ast::Object::getD ( std::string const & attrib ) const

inlineprotectedinherited

Get the value of an attribute as a double.

If possible, the attribute value is converted to the type you request.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 374 of file Object.h.

                                                {
         double val = astGetD(getRawPtr(), attrib.c_str());
         assertOK();
         return val;
     }

◆ getDigits() [1/2]

int ast::Frame::getDigits ( ) const

inlineinherited

Get Digits: the default used if no specific value specified for an axis.

Definition at line 812 of file Frame.h.

812 { return getI("Digits"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getDigits() [2/2]

int ast::Frame::getDigits ( int axis ) const

inlineinherited

Get Digits for one axis.

Definition at line 817 of file Frame.h.

817 { return getI(detail::formatAxisAttr("Digits", axis)); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

◆ getDirection()

bool ast::Frame::getDirection ( int axis ) const

inlineinherited

Get Direction for one axis: display axis in conventional direction?

Definition at line 822 of file Frame.h.

822 { return getB(detail::formatAxisAttr("Direction", axis)); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

◆ getDomain()

std::string ast::Frame::getDomain ( ) const

inlineinherited

Get Domain: coordinate system domain.

Definition at line 827 of file Frame.h.

827 { return getC("Domain"); }

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getDut1()

double ast::Frame::getDut1 ( ) const

inlineinherited

Get Dut1: difference between the UT1 and UTC timescale (sec)

Definition at line 832 of file Frame.h.

832 { return getD("Dut1"); }

double getD(std::string const &attrib) const

Get the value of an attribute as a double.

Definition: Object.h:374

◆ getEpoch()

double ast::Frame::getEpoch ( ) const

inlineinherited

Get Epoch: Epoch of observation.

Definition at line 837 of file Frame.h.

837 { return getD("Epoch"); }

double getD(std::string const &attrib) const

Get the value of an attribute as a double.

Definition: Object.h:374

◆ getF()

float ast::Object::getF ( std::string const & attrib ) const

inlineprotectedinherited

Get the value of an attribute as a float.

If possible, the attribute value is converted to the type you request.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 387 of file Object.h.

                                               {
         float val = astGetF(getRawPtr(), attrib.c_str());
         assertOK();
         return val;
     }

◆ getFormat()

std::string ast::Frame::getFormat ( int axis ) const

inlineinherited

Get Format for one axis: format specification for axis values.

Definition at line 842 of file Frame.h.

842 { return getC(detail::formatAxisAttr("Format", axis)); }

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getFrame() [1/2]

std::shared_ptr<Frame> ast::FrameDict::getFrame	(	std::string const &	domain,
		bool	copy = `true`
	)		const

inline

Variant of getFrame(int, bool) where the frame is specified by domain name.

Exceptions

std::out_of_range if no frame found with the specified domain

Definition at line 151 of file FrameDict.h.

                                                                                    {
         return getFrame(getIndex(domain), copy);
     }

◆ getFrame() [2/2]

std::shared_ptr<Frame> ast::FrameSet::getFrame	(	int	iframe,
		bool	copy = `true`
	)		const

inlineinherited

Obtain a deep copy of the specified Frame.

Parameters

[in]	iframe	The index of the required Frame within this FrameSet. This value should lie in the range 1 to the number of frames already in this FrameSet (as given by getNFrame). A value of FrameSet::Base or FrameSet::CURRENT may be given to specify the base Frame or the current Frame, respectively.
[in]	copy	If true return a deep copy, else a shallow copy.

Warning: : to permute axes of a frame in a FrameSet, such that the connecting mappings are updated: set the current frame to the frame in question and call permAxes directly on the FrameSet. Do not call permAxes on a shallow copy of the frame (retrieved by getFrame) as this will not affect the connected mappings.

Definition at line 270 of file FrameSet.h.

                                                                       {
         auto *rawFrame = reinterpret_cast<AstObject *>(astGetFrame(getRawPtr(), iframe));
         assertOK(rawFrame);
         if (!rawFrame) {
             throw std::runtime_error("getFrame failed (returned a null frame)");
         }
         return Object::fromAstObject<Frame>(rawFrame, copy);
     }

◆ getFrameSet()

std::shared_ptr<FrameSet> ast::FrameDict::getFrameSet ( ) const

inlineprotected

Return a deep copy as a FrameSet.

This is used internally for operations that modify the contents:

Retrieve a copy as a FrameSet
Modify the copy
Call _update to construct a new domain:index dict from the copy and swap in the new data

This could be a public member function, but wait until a need is identified.

Warning: this must return a FrameSet, not a FrameDict in order to avoid an infinite loop.

Definition at line 273 of file FrameDict.h.

                                                 {
         return std::static_pointer_cast<FrameSet>(copyImpl<FrameSet, AstFrameSet>());
     }

◆ getI()

int ast::Object::getI ( std::string const & attrib ) const

inlineprotectedinherited

Get the value of an attribute as an int.

If possible, the attribute value is converted to the type you request.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 400 of file Object.h.

                                             {
         int val = astGetI(getRawPtr(), attrib.c_str());
         assertOK();
         return val;
     }

◆ getID()

std::string ast::Object::getID ( ) const

inlineinherited

Get ID: object identification string that is not copied.

Definition at line 142 of file Object.h.

142 { return getC("ID"); }

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getIdent()

std::string ast::Object::getIdent ( ) const

inlineinherited

Get Ident: object identification string that is copied.

Definition at line 145 of file Object.h.

145 { return getC("Ident"); }

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getIndex()

int ast::FrameDict::getIndex ( std::string const & domain ) const

inline

Get the index of a frame specified by domain.

Exceptions

std::out_of_range if no frame found with the specified domain

Definition at line 189 of file FrameDict.h.

                                                 {
         auto domainUpper = detail::stringToUpper(domain);
         auto it = _domainIndexDict.find(domainUpper);
         if (it == _domainIndexDict.end()) {
             throw std::out_of_range("No frame found with domain " + domain);
         }
         return it->second;
     }

◆ getInternalUnit()

std::string ast::Frame::getInternalUnit ( int axis ) const

inlineinherited

Get InternalUnit(axis) read-only attribute for one axis: physical units for unformated axis values.

Definition at line 848 of file Frame.h.

848 { return getC(detail::formatAxisAttr("InternalUnit", axis)); }

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getIsLinear()

bool ast::Mapping::getIsLinear ( ) const

inlineinherited

Get IsLinear: is the Mapping linear?

Definition at line 100 of file Mapping.h.

100 { return getB("IsLinear"); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

◆ getIsSimple()

bool ast::Mapping::getIsSimple ( ) const

inlineinherited

Get IsSimple: has the mapping been simplified?

Definition at line 87 of file Mapping.h.

87 { return getI("IsSimple"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getL()

long int ast::Object::getL ( std::string const & attrib ) const

inlineprotectedinherited

Get the value of an attribute as a long int.

If possible, the attribute value is converted to the type you request.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 413 of file Object.h.

                                                  {
         long int val = astGetL(getRawPtr(), attrib.c_str());
         assertOK();
         return val;
     }

◆ getLabel()

std::string ast::Frame::getLabel ( int axis ) const

inlineinherited

Get Label(axis) for one axis: axis label.

Definition at line 853 of file Frame.h.

853 { return getC(detail::formatAxisAttr("Label", axis)); }

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getMapping() [1/4]

std::shared_ptr<Mapping> ast::FrameDict::getMapping	(	int	from,
		std::string const &	to
	)		const

inline

Variant of FrameSet::getMapping with the second frame specified by domain.

Exceptions

std::out_of_range if no frame found with the specified from or to domain

Definition at line 162 of file FrameDict.h.

                                                                            {
         return getMapping(from, getIndex(to));
     }

◆ getMapping() [2/4]

std::shared_ptr<Mapping> ast::FrameDict::getMapping	(	std::string const &	from,
		int	to
	)		const

inline

Variant of FrameSet::getMapping with the first frame specified by domain.

Exceptions

std::out_of_range if no frame found with the specified from or to domain

Definition at line 171 of file FrameDict.h.

                                                                            {
         return getMapping(getIndex(from), to);
     }

◆ getMapping() [3/4]

std::shared_ptr<Mapping> ast::FrameDict::getMapping	(	std::string const &	from,
		std::string const &	to
	)		const

inline

Variant of FrameSet::getMapping with the both frames specified by domain.

Exceptions

std::out_of_range if no frame found with the specified from or to domain

Definition at line 180 of file FrameDict.h.

                                                                                         {
         return getMapping(getIndex(from), getIndex(to));
     }

◆ getMapping() [4/4]

std::shared_ptr<Mapping> ast::FrameSet::getMapping	(	int	from = `BASE`,
		int	to = `CURRENT`
	)		const

inlineinherited

Obtain a Mapping that converts between two Frames in a FrameSet.

Parameters

[in]	from	The index of the first Frame in the FrameSet, the frame describing the coordinate system for the "input" end of the Mapping. This value should lie in the range 1 to the number of frames already in this FrameSet (as given by getNFrame).
[in]	to	The index of the second Frame in the FrameSet, the frame describing the coordinate system for the "output" end of the Mapping. This value should lie in the range 1 to the number of frames already in this FrameSet (as given by getNFrame).

Returns: A Mapping whose forward transformation converts coordinates from the first frame to the second one, and whose inverse transformation converts coordinates in the opposite direction.

Notes

The returned Mapping will include the clipping effect of any Regions which occur on the path between the two supplied Frames, including the specified end frames.
It should always be possible to generate the Mapping requested, but this does not necessarily guarantee that it will be able to perform the required coordinate conversion. If necessary, call hasForward or hasInverse on the returned Mapping to determine if the required transformation is available.

Definition at line 304 of file FrameSet.h.

                                                                                {
         AstObject *rawMap = reinterpret_cast<AstObject *>(astGetMapping(getRawPtr(), from, to));
         assertOK(rawMap);
         if (!rawMap) {
             throw std::runtime_error("getMapping failed (returned a null mapping)");
         }
         return Object::fromAstObject<Mapping>(rawMap, true);
     }

◆ getMatchEnd()

bool ast::Frame::getMatchEnd ( ) const

inlineinherited

Get MatchEnd: match trailing axes?

Definition at line 858 of file Frame.h.

858 { return getB("MatchEnd"); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

◆ getMaxAxes()

int ast::Frame::getMaxAxes ( ) const

inlineinherited

Get MaxAxes: the maximum axes a frame found by findFrame may have.

Definition at line 864 of file Frame.h.

864 { return getI("MaxAxes"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getMinAxes()

int ast::Frame::getMinAxes ( ) const

inlineinherited

Get MinAxes: the maximum axes a frame found by findFrame may have.

Definition at line 870 of file Frame.h.

870 { return getI("MinAxes"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getNAxes()

int ast::Frame::getNAxes ( ) const

inlineinherited

Get NAxes: the number of axes in the frame (i.e.

the number of dimensions of the coordinate space which the Frame describes).

Definition at line 876 of file Frame.h.

876 { return getI("NAxes"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getNFrame()

int ast::FrameSet::getNFrame ( ) const

inlineinherited

Get FrameSet_NFrame "NFrame": number of Frames in the FrameSet, starting from 1.

Definition at line 316 of file FrameSet.h.

316 { return getI("NFrame"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getNIn()

int ast::Mapping::getNIn ( ) const

inlineinherited

Get NIn: the number of input axes.

Definition at line 77 of file Mapping.h.

77 { return getI("NIn"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getNObject()

int ast::Object::getNObject ( ) const

inlineinherited

Get NObject: number of AST objects in existence of the same type as the underlying AST class.

Warning: Intended only for debugging astshim.

Definition at line 153 of file Object.h.

153 { return getI("NObject"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getNormUnit()

std::string ast::Frame::getNormUnit ( int axis ) const

inlineinherited

Get NormUnit(axis) read-only attribute for one frame: normalised physical units for formatted axis values.

Definition at line 882 of file Frame.h.

882 { return getC(detail::formatAxisAttr("NormUnit", axis)); }

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getNOut()

int ast::Mapping::getNOut ( ) const

inlineinherited

Get NOut: the number of output axes.

Definition at line 82 of file Mapping.h.

82 { return getI("NOut"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getObjSize()

int ast::Object::getObjSize ( ) const

inlineinherited

Get ObjSize: the in-memory size of the AST object in bytes.

Definition at line 156 of file Object.h.

156 { return getI("ObjSize"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getObsAlt()

double ast::Frame::getObsAlt ( ) const

inlineinherited

Get ObsAlt: Geodetic altitude of observer (m).

Definition at line 887 of file Frame.h.

887 { return getD("ObsAlt"); }

double getD(std::string const &attrib) const

Get the value of an attribute as a double.

Definition: Object.h:374

◆ getObsLat()

std::string ast::Frame::getObsLat ( ) const

inlineinherited

Get ObsLat: Geodetic latitude of observer.

Definition at line 892 of file Frame.h.

892 { return getC("ObsLat"); }

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getObsLon()

std::string ast::Frame::getObsLon ( ) const

inlineinherited

Get ObsLon: Geodetic longitude of observer.

Definition at line 897 of file Frame.h.

897 { return getC("ObsLon"); }

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getPermute()

bool ast::Frame::getPermute ( ) const

inlineinherited

Get Permute: allow axis permutation when used as a template?

Definition at line 902 of file Frame.h.

902 { return getB("Permute"); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

◆ getPreserveAxes()

bool ast::Frame::getPreserveAxes ( ) const

inlineinherited

Get PreserveAxes: preserve axes?

Definition at line 907 of file Frame.h.

907 { return getB("PreserveAxes"); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

◆ getRawPtr() [1/2]

AstObject const* ast::Object::getRawPtr ( ) const

inlineinherited

Get the raw AST pointer.

Intended for internal use only, but cannot be made protected without endless "friend class" declarations.

Definition at line 292 of file Object.h.

292 { return &*_objPtr; };

◆ getRawPtr() [2/2]

AstObject* ast::Object::getRawPtr ( )

inlineinherited

Get the raw AST pointer.

Intended for internal use only, but cannot be made protected without endless "friend class" declarations.

Definition at line 294 of file Object.h.

294 { return &*_objPtr; };

◆ getRefCount()

int ast::Object::getRefCount ( ) const

inlineinherited

Get RefCount: number of active pointers to the underlying AST object.

Warning: Intended only for debugging astshim.

Definition at line 163 of file Object.h.

163 { return getI("RefCount"); }

int getI(std::string const &attrib) const

Get the value of an attribute as an int.

Definition: Object.h:400

◆ getReport()

bool ast::Mapping::getReport ( ) const

inlineinherited

Get Report: report transformed coordinates to stdout?

Definition at line 105 of file Mapping.h.

105 { return getB("Report"); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

◆ getSymbol()

std::string ast::Frame::getSymbol ( int axis ) const

inlineinherited

Get Symbol(axis) for one axis: axis symbol.

Definition at line 912 of file Frame.h.

912 { return getC(detail::formatAxisAttr("Symbol", axis)); }

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getSystem()

std::string ast::Frame::getSystem ( ) const

inlineinherited

Get System: coordinate system used to describe positions within the domain.

Definition at line 918 of file Frame.h.

918 { return getC("System"); }

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getTitle()

std::string ast::Frame::getTitle ( ) const

inlineinherited

Get Title: frame title.

Definition at line 923 of file Frame.h.

923 { return getC("Title"); }

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getTop()

double ast::Frame::getTop ( int axis ) const

inlineinherited

Get Top: the highest axis value to display.

Definition at line 928 of file Frame.h.

928 { return getD(detail::formatAxisAttr("Top", axis)); }

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

double getD(std::string const &attrib) const

Get the value of an attribute as a double.

Definition: Object.h:374

◆ getUnit()

std::string ast::Frame::getUnit ( int axis ) const

inlineinherited

Get Unit(axis) for one axis: physical units for formatted axis values.

Definition at line 933 of file Frame.h.

933 { return getC(detail::formatAxisAttr("Unit", axis)); }

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ getUseDefs()

bool ast::Object::getUseDefs ( ) const

inlineinherited

Get UseDefs: allow use of default values for Object attributes?

Definition at line 166 of file Object.h.

166 { return getB("UseDefs"); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

◆ getVariant()

std::string ast::FrameSet::getVariant ( ) const

inlineinherited

Variant: name of variant mapping in use by current Frame

See also addVariant, mirrorVariants and renameVariant

Definition at line 323 of file FrameSet.h.

323 { return getC("Variant"); }

std::unordered_map::count

std::string const getC(std::string const &attrib) const

Get the value of an attribute as a string.

Definition: Object.h:361

◆ hasAttribute()

bool ast::Object::hasAttribute ( std::string const & attrib ) const

inlineinherited

Does this object have an attribute with the specified name?

Definition at line 127 of file Object.h.

                                                      {
         bool ret = astHasAttribute(getRawPtr(), attrib.c_str());
         assertOK();
         return ret;
     }

◆ hasDomain()

bool ast::FrameDict::hasDomain ( std::string const & domain ) const

inline

Return True if a frame in this FrameDict has the specified domain.

Definition at line 201 of file FrameDict.h.

201 { return _domainIndexDict.count(domain) > 0; }

T count(T... args)

◆ hasForward()

bool ast::Mapping::hasForward ( ) const

inlineinherited

Is the forward transform available?

Note: This gets the TranForward attribute, but is named hasForward instead of getTranForward for clarity, since it does not return a transform.

Definition at line 114 of file Mapping.h.

114 { return getB("TranForward"); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

◆ hasInverse()

bool ast::Mapping::hasInverse ( ) const

inlineinherited

Is the inverse transform available?

Note: This gets the TranInverse attribute, but is named hasInverse instead of getTranInverse for clarity, since it does not return a transform.

Definition at line 123 of file Mapping.h.

123 { return getB("TranInverse"); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

◆ intersect()

std::vector< double > ast::Frame::intersect	(	std::vector< double > const &	a1,
		std::vector< double > const &	a2,
		std::vector< double > const &	b1,
		std::vector< double > const &	b2
	)		const

inherited

Find the point of intersection between two geodesic curves.

For example, in a basic Frame, it will find the point of intersection between two straight lines. But for a SkyFrame it will find an intersection of two great circles.

Warning: This method can only be used with 2-dimensional Frames.

Parameters

[in]	a1	Coordinates of the first point on the first geodesic curve.
[in]	a2	Coordinates of the second point on the first geodesic curve.
[in]	b1	Coordinates of the first point on the second geodesic curve.
[in]	b2	Coordinates of the second point on the second geodesic curve.

Returns: the point of intersection between the two geodesic curves.

Exceptions

std::runtime_error if the frame is not 2-dimensional

Notes

For a SkyFrame each curve will be a great circle, and in general each pair of curves will intersect at two diametrically opposite points on the sky. The returned position is the one which is closest to point a1.
This method will return nan coordinate values if any of the input coordinates is invalid, or if the two points defining either geodesic are coincident, or if the two curves do not intersect.
The geodesic curve used by this method is the path of shortest distance between two points, as defined by distance

Definition at line 51 of file Frame.cc.

                                                                                                      {
     int const naxes = 2;
     detail::assertEqual(getNAxes(), "# axes", naxes, "");
     detail::assertEqual(a1.size(), "a1.size()", static_cast<std::size_t>(naxes), "");
     detail::assertEqual(a2.size(), "a2.size()", static_cast<std::size_t>(naxes), "");
     detail::assertEqual(b1.size(), "b1.size()", static_cast<std::size_t>(naxes), "");
     detail::assertEqual(b2.size(), "b2.size()", static_cast<std::size_t>(naxes), "");
     std::vector<double> ret(naxes);
     astIntersect(getRawPtr(), a1.data(), a2.data(), b1.data(), b2.data(), ret.data());
     assertOK();
     detail::astBadToNan(ret);
     return ret;
 }

◆ inverted()

std::shared_ptr< Mapping > ast::Mapping::inverted ( ) const

inherited

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

Definition at line 41 of file Mapping.cc.

                                                {
     auto rawCopy = reinterpret_cast<AstMapping *>(astCopy(getRawPtr()));
     astInvert(rawCopy);
     assertOK(reinterpret_cast<AstObject *>(rawCopy));
     // use false because the pointer has already been copied
     return Object::fromAstObject<Mapping>(reinterpret_cast<AstObject *>(rawCopy), false);
 }

◆ isInverted()

bool ast::Mapping::isInverted ( ) const

inlineinherited

Is this an inverted mapping?

Note: this gets the Invert attribute. This method is not called getInvert because that sounds like it might return the inverse.

Definition at line 95 of file Mapping.h.

95 { return getB("Invert"); }

bool getB(std::string const &attrib) const

Get the value of an attribute as a bool.

Definition: Object.h:348

◆ linearApprox()

Array2D ast::Mapping::linearApprox	(	PointD const &	lbnd,
		PointD const &	ubnd,
		double	tol
	)		const

inherited

Compute a linear approximation to the forward transformation.

Parameters

[in]	lbnd	Input point defining the lower bounds of the box over which the linear approximation is computed.
[in]	ubnd	Input point defining the upper bounds of the box over which the linear approximation is computed.
[in]	tol	The maximum permitted deviation from linearity, expressed as apositive Cartesian displacement in the output coordinate space. If a linear fit to the forward transformation of the Mapping deviates from the true transformation by more than this amount at any point which is tested, then raise an exception.

Returns

The co-efficients of the linear approximation to the specified transformation, as an 1 + nIn x nOut array. The first index is [constant, gradiant for input 1, gradiant for input 2...] and the second index is [output 1, output 2, ...]. For example, if the Mapping has 2 inputs and 3 outputs then the coefficients are:

X_out = fit[0, 0] + fit[1, 0] X_in + fit[2, 0] Y_in
Y_out = fit[0, 1] + fit[1, 1] X_in + fit[2, 1] Y_in
Z_out = fit[0, 2] + fit[1, 2] X_in + fit[2, 2] Y_in

Exceptions

std::runtime_error if the forward transformation cannot be modeled to within the specified tol.

Definition at line 49 of file Mapping.cc.

                                                                                       {
     int const nIn = getNIn();
     int const nOut = getNOut();
     detail::assertEqual(lbnd.size(), "lbnd.size", static_cast<std::size_t>(nIn), "nIn");
     detail::assertEqual(ubnd.size(), "ubnd.size", static_cast<std::size_t>(nIn), "nIn");
     Array2D fit = ndarray::allocate(ndarray::makeVector(1 + nIn, nOut));
     int isOK = astLinearApprox(getRawPtr(), lbnd.data(), ubnd.data(), tol, fit.getData());
     assertOK();
     if (!isOK) {
         throw std::runtime_error("Mapping not sufficiently linear");
     }
     return fit;
 }

◆ lock()

void ast::Object::lock ( bool wait )

inlineinherited

Lock this object for exclusive use by the calling thread.

The thread-safe public interface to AST is designed so that an error is reported if any thread attempts to use an Object that it has not previously locked for its own exclusive use using this function. When an Object is created, it is initially locked by the thread that creates it, so newly created objects do not need to be explicitly locked. However, if an Object pointer is passed to another thread, the original thread must first unlock it (using astUnlock) and the new thread must then lock it (using astLock) before the new thread can use the Object.

Parameters

[in] wait If the Object is curently locked by another thread then this function will either report an error or block. If a non-zero value is supplied for "wait", the calling thread waits until the object is available for it to use. Otherwise, an error is reported and the function returns immediately without locking the Object.

Notes

The Locked object will belong to the current AST context.
This function returns without action if the Object is already locked by the calling thread.
If simultaneous use of the same object is required by two or more threads, Object::copy should be used to to produce a deep copy of the Object for each thread. Each copy should then be unlocked by the parent thread (i.e. the thread that created the copy), and then locked by the child thread (i.e. the thread that wants to use the copy).
This function returns without action if the AST library has been built without POSIX thread support (i.e. the "-with-pthreads" option was not specified when running the "configure" script).

Definition at line 202 of file Object.h.

                          {
         astLock(getRawPtr(), static_cast<int>(wait));
         assertOK();
     }

◆ makeShim()

template<typename ShimT , typename AstT >

static std::shared_ptr<ShimT> ast::Object::makeShim ( AstObject * p )

inlinestaticprotectedinherited

Functor to make an astshim instance from a raw AST pointer of the corresponding type.

Template Parameters

ShimT	Output astshim class
AstT	Output AST class

Definition at line 310 of file Object.h.

                                                        {
         return std::shared_ptr<ShimT>(new ShimT(reinterpret_cast<AstT *>(p)));
     }

◆ matchAxes()

std::vector<int> ast::Frame::matchAxes ( Frame const & other ) const

inlineinherited

Look for corresponding axes between this frame and another.

Parameters

[in] other The other frame

Returns: The indices of the axes (within this Frame) that correspond to each axis within other. Axis indices start at 1. A value of zero will be stored in the returned array for each axis in other that has no corresponding axis in this frame. The number of elements in the array will be the number of axes in other.

Notes

Corresponding axes are identified by the fact that a Mapping can be found between them using findFrame or convert. Thus, "corresponding axes" are not necessarily identical. For instance, SkyFrame axes will match even if they describe different celestial coordinate systems.

Definition at line 985 of file Frame.h.

                                                        {
         std::vector<int> ret(other.getNIn());
         astMatchAxes(getRawPtr(), other.getRawPtr(), ret.data());
         assertOK();
         return ret;
     }

◆ mirrorVariants() [1/2]

void ast::FrameDict::mirrorVariants ( std::string const & domain )

inline

Variant of mirrorVariants(int) with the frame specified by domain.

Exceptions

std::out_of_range if no frame found with the specified domain

Definition at line 210 of file FrameDict.h.

210 { mirrorVariants(getIndex(domain)); }

ast::FrameDict::mirrorVariants

int getIndex(std::string const &domain) const

Get the index of a frame specified by domain.

Definition: FrameDict.h:189

void mirrorVariants(std::string const &domain)

Variant of mirrorVariants(int) with the frame specified by domain.

Definition: FrameDict.h:210

◆ mirrorVariants() [2/2]

void ast::FrameSet::mirrorVariants ( int iframe )

inlineinherited

Indicates that all access to the Variant attribute of the current Frame should should be forwarded to some other nominated Frame in the FrameSet.

For instance, if a value is set subsequently for the Variant attribute of the current Frame, the current Frame will be left unchanged and the setting is instead applied to the nominated Frame. Likewise, if the value of the Variant attribute is requested, the value returned is the value stored for the nominated Frame rather than the current Frame itself.

This provides a mechanism for propagating the effects of variant Mappings around a FrameSet. If a new Frame is added to a FrameSet by connecting it to an pre-existing Frame that has two or more variant Mappings, then it may be appropriate to set the new Frame so that it mirrors the variants Mappings of the pre-existing Frame. If this is done, then it will be possible to select a specific variant Mapping using either the pre-existing Frame or the new Frame.

See also addVariant, getVariant and renameVariant.

Parameters

[in] iframe The index of the Frame within the FrameSet which is to be mirrored by the current Frame. This value should lie in the range from 1 to the number of Frames in the FrameSet (as given by getNFrame). If AST__NOFRAME is supplied (or the current Frame is specified), then any mirroring established by a previous call to this function is disabled. A value of FrameSet::BASE may be given to specify the base frame.

Notes:

Mirrors can be chained. That is, if Frame B is set to be a mirror of Frame A, and Frame C is set to be a mirror of Frame B, then Frame C will act as a mirror of Frame A.
Variant Mappings cannot be added to the current Frame if it is mirroring another Frame. So calls to addVariant will cause an error to be reported if the current Frame is mirroring another Frame.
Any variant Mappings explicitly added to the current Frame using addVariant will be ignored if the current Frame is mirroring another Frame.

Definition at line 367 of file FrameSet.h.

                                     {
         astMirrorVariants(getRawPtr(), iframe);
         assertOK();
     }

◆ norm()

PointD ast::Frame::norm ( PointD value ) const

inlineinherited

Normalise a set of Frame coordinate values which might be unsuitable for display (e.g.

may lie outside the expected range) into a set of acceptable values suitable for display.

Parameters

[in] value A point in the space which the Frame describes.

Returns: Normalized version of value. If any axes of value lie outside the expected range for the Frame, the corresponding returned value is changed to a acceptable (normalised) value. Otherwise, the axes of value are returned unchanged.

Notes

For some classes of Frame, whose coordinate values are not constrained, this function will always return the input unchanged. However, for Frames whose axes represent cyclic quantities (such as angles or positions on the sky), the output coordinates will typically be wrapped into an appropriate standard range, such as [0, 2 pi].
The NormMap class is a Mapping which can be used to normalise a set of points using the norm function of a specified Frame.
It is intended to be possible to put any set of coordinates into a form suitable for display by using this function to normalise them, followed by appropriate formatting (using astFormat).

Definition at line 1045 of file Frame.h.

                                     {
         astNorm(getRawPtr(), value.data());
         assertOK();
         detail::astBadToNan(value);
         return value;
     }

◆ offset()

PointD ast::Frame::offset	(	PointD	point1,
		PointD	point2,
		double	offset
	)		const

inlineinherited

Find the point which is offset a specified distance along the geodesic curve between two other points.

For example, in a basic Frame, this offset will be along the straight line joining two points. For a more specialised Frame describing a sky coordinate system, however, it would be along the great circle passing through two sky positions.

Parameters

[in]	point1	The point marking the start of the geodesic curve.
[in]	point2	The point marking the end of the geodesic curve.
[in]	offset	The required offset from the first point along the geodesic curve. If this is positive, it will be towards the second point. If it is negative, it will be in the opposite direction. This offset need not imply a position lying between the two points given, as the curve will be extrapolated if necessary.

Returns: the offset point

Notes:

The geodesic curve used by this function is the path of shortest distance between two points, as defined by the distance function.

Exceptions

std::invalid_argument

if:

point1 or point2 is the wrong length

Definition at line 1075 of file Frame.h.

                                                                      {
         assertPointLength(point1, "point1");
         assertPointLength(point2, "point2");
         PointD ret(getNIn());
         astOffset(getRawPtr(), point1.data(), point2.data(), offset, ret.data());
         assertOK();
         detail::astBadToNan(ret);
         return ret;
     }

◆ offset2()

DirectionPoint ast::Frame::offset2	(	PointD const &	point1,
		double	angle,
		double	offset
	)		const

inlineinherited

Find the point which is offset a specified distance along the geodesic curve at a given angle from a specified starting point.

This can only be used with 2-dimensional Frames.

For example, in a basic Frame, this offset will be along the straight line joining two points. For a more specialised Frame describing a sky coordinate system, however, it would be along the great circle passing through two sky positions.

Parameters

[in]	point1	The point marking the start of the geodesic curve.
[in]	angle	The angle (in radians) from the positive direction of the second axis, to the direction of the required position, as seen from the starting position. Positive rotation is in the sense of rotation from the positive direction of axis 2 to the positive direction of axis 1.
[in]	offset	The required offset from the first point along the geodesic curve. If this is positive, it will be in the direction of the given angle. If it is negative, it will be in the opposite direction.

Returns

a DirectionPoint containing:

The direction of the geodesic curve at the end point. That is, the angle (in radians) between the positive direction of the second axis and the continuation of the geodesic curve at the requested end point. Positive rotation is in the sense of rotation from the positive direction of axis 2 to the positive direction of axis 1.
The offset point.

Exceptions

std::invalid_argument

if

frame does not have naxes = 2
point1 or point2 are the wrong length, or point1 has any AST__BAD values

Notes

The geodesic curve used by this function is the path of shortest distance between two points, as defined by the astDistance function

Definition at line 1117 of file Frame.h.

                                                                                     {
         detail::assertEqual(getNIn(), "naxes", 2, " cannot call offset2");
         assertPointLength(point1, "point1");
         PointD point2(getNIn());
         double offsetAngle = astOffset2(getRawPtr(), point1.data(), angle, offset, point2.data());
         assertOK();
         detail::astBadToNan(point2);
         return DirectionPoint(detail::safeDouble(offsetAngle), point2);
     }

◆ operator!=()

bool ast::Object::operator!= ( Object const & rhs ) const

inlineinherited

Return True if this and rhs are not equal.

See operator== for details

Definition at line 82 of file Object.h.

82 {

83 return !(*this == rhs); };

◆ operator=() [1/2]

FrameDict& ast::FrameDict::operator= ( FrameDict const & )

delete

◆ operator=() [2/2]

FrameDict& ast::FrameDict::operator= ( FrameDict && )

default

◆ operator==()

bool ast::Object::operator== ( Object const & rhs ) const

inherited

Return True if this and rhs are the equal.

For two objects be equal, they both must have the same attributes and all contained objects must be equal.

Definition at line 85 of file Object.cc.

                                                {
     auto thisStr = this->show(false);
     auto rhsStr = rhs.show(false);
     return rhsStr == thisStr;
 }

◆ permAxes()

void ast::Frame::permAxes ( std::vector< int > perm )

inlineinherited

Permute the order in which a Frame's axes occur.

Parameters

[in] perm A list of axes in their new order, using the current axis numbering. Axis numbers start at 1 for the first axis. Only genuine permutations of the axis order are permitted, so each axis must be referenced exactly once.

When used on a FrameSet, the axes of the current frame are permuted and all connecting mappings are updated accordingly, so that current behavior is preserved (except for the new axis order for output data).

Definition at line 1138 of file Frame.h.

                                        {
         detail::assertEqual(perm.size(), "perm.size()", static_cast<std::size_t>(getNAxes()), "naxes");
         astPermAxes(getRawPtr(), perm.data());
         assertOK();
     }

◆ pickAxes()

FrameMapping ast::Frame::pickAxes ( std::vector< int > const & axes ) const

inherited

Create a new Frame whose axes are copied from an existing Frame along with other Frame attributes, such as its Title.

Any number (zero or more) of the original Frame's axes may be copied, in any order, and additional axes with default attributes may also be included in the new Frame.

Parameters

[in] axes the axes to be copied. These should be given in the order required in the new Frame, using the axis numbering in the original Frame (which starts at 1 for the first axis). Axes may be selected in any order, but each may only be used once. If additional (default) axes are also to be included, the corresponding elements of this array should be set to zero.

Returns

a FrameMapping containing:

The new frame.
A mapping (usually a PermMap, but may be a UnitMap) that describes the axis permutation that has taken place between the original and new Frames. The Mapping's forward transformation will convert coordinates from the original Frame into the new one, and vice versa.

Definition at line 68 of file Frame.cc.

                                                              {
     AstMapping *rawMap;
     auto *rawFrame =
             reinterpret_cast<AstFrame *>(astPickAxes(getRawPtr(), axes.size(), axes.data(), &rawMap));
     assertOK(reinterpret_cast<AstObject *>(rawFrame), reinterpret_cast<AstObject *>(rawMap));
     std::shared_ptr<Frame> frame;
     try {
         frame = Object::fromAstObject<Frame>(reinterpret_cast<AstObject *>(rawFrame), false);
     } catch (...) {
         astAnnul(rawMap);
         throw;
     }
     auto map = Object::fromAstObject<Mapping>(reinterpret_cast<AstObject *>(rawMap), false);
     return FrameMapping(frame, map);
 }

◆ rate()

double ast::Mapping::rate	(	PointD const &	at,
		int	ax1,
		int	ax2
	)		const

inlineinherited

Evaluate the rate of change of the Mapping with respect to a specified input, at a specified position.

The result is estimated by interpolating the function using a fourth order polynomial in the neighbourhood of the specified position. The size of the neighbourhood used is chosen to minimise the RMS residual per unit length between the interpolating polynomial and the supplied Mapping function. This method produces good accuracy but can involve evaluating the Mapping 100 or more times.

Parameters

[in]	at	The input position at which the rate of change is to be evaluated.
[in]	ax1	The index of the output for which the rate of change is to be found (1 for first output).
[in]	ax2	The index of the input which is to be varied in order to find the rate of change (1 for the first input).

Returns: The rate of change of Mapping output ax1 with respect to input ax2, evaluated at at, or nan if the value cannot be calculated.

Definition at line 215 of file Mapping.h.

                                                           {
         detail::assertEqual(at.size(), "at.size", static_cast<std::size_t>(getNIn()), "nIn");
         double result = astRate(getRawPtr(), const_cast<double *>(at.data()), ax1, ax2);
         assertOK();
         return result;
     }

◆ remapFrame() [1/2]

void ast::FrameDict::remapFrame	(	std::string const &	domain,
		Mapping &	map
	)

inline

Variant of remapFrame(int, Mapping&) with the frame specified by domain.

Exceptions

std::out_of_range if no frame found with the specified domain

Definition at line 219 of file FrameDict.h.

219 { remapFrame(getIndex(domain), map); }

ast::FrameDict::remapFrame

int getIndex(std::string const &domain) const

Get the index of a frame specified by domain.

Definition: FrameDict.h:189

void remapFrame(std::string const &domain, Mapping &map)

Variant of remapFrame(int, Mapping&) with the frame specified by domain.

Definition: FrameDict.h:219

◆ remapFrame() [2/2]

void ast::FrameSet::remapFrame	(	int	iframe,
		Mapping &	map
	)

inlineinherited

Modify the relationship (i.e.

Mapping) between a specified Frame in a FrameSet and the other Frames in that FrameSet.

Typically, this might be required if the FrameSet has been used to calibrate (say) an image, and that image is re-binned. The Frame describing the image will then have undergone a coordinate transformation, and this should be communicated to the associated FrameSet using this function.

See also addVariant, getVariant and mirrorVariants.

Parameters

[in]	iframe	The index within the FrameSet of the Frame to be modified. This value should lie in the range 1 to the number of frames already in this FrameSet (as given by getNFrame). A value of FrameSet::BASE or FrameSet::CURRENT may be given to specify the base Frame or the current Frame respectively.
[in]	map	A Mapping whose forward transformation converts coordinate values from the original coordinate system described by the Frame to the new one, and whose inverse transformation converts in the opposite direction.

Notes

The relationship between the selected Frame and any other Frame within the FrameSet will be modified by this function, but the relationship between all other Frames in the FrameSet remains unchanged.
The number of input and output coordinate values of the Mapping must be equal and must match the number of axes in the Frame being modified.
If a simple change of axis order is required, then permAxes may provide a more straightforward method of making the required changes to the FrameSet.
This function cannot be used to change the number of Frame axes. To achieve this, a new Frame must be added to the FrameSet (with addFrame) and the original one removed if necessary (with removeFrame).
Any variant Mappings associated with the remapped Frame (except for the current variant) will be lost as a consequence of calling this method (see attribute Variant).

Definition at line 410 of file FrameSet.h.

                                               {
         astRemapFrame(getRawPtr(), iframe, map.copy()->getRawPtr());
         assertOK();
     };

◆ removeFrame() [1/2]

void ast::FrameDict::removeFrame ( int iframe )

overridevirtual

Remove a Frame from a FrameSet.

Other Frame indices in the FrameSet are re-numbered as follows: Frame indices greater than iframe are decremented by one; other Frame indeces retain the same index.

Parameters

[in] iframe The index of the required Frame within this FrameSet. This value should lie in the range 1 to the number of Frames in this FrameSet (as given by getNFrame). A value of FrameSet::BASE or FrameSet::CURRENT may be given to specify the base Frame or the current Frame, respectively.

Notes

Removing a Frame from a FrameSet does not affect the relationship between other Frames in this FrameSet, even if they originally depended on the Frame being removed.
The number of Frames in a FrameSet cannot be reduced to zero.
If a FrameSet's base or current Frame is removed, the Base or Current attribute (respectively) of the FrameSet will have its value cleared, so that another Frame will then assume its role by default.
If any other Frame is removed, the base and current Frames will remain the same. To ensure this, the Base and/or Current attributes of the FrameSet will be changed, if necessary, to reflect any change in the indices of these Frames.

Exceptions

std::runtime_error if you attempt to remove the last frame

Reimplemented from ast::FrameSet.

Definition at line 53 of file FrameDict.cc.

                                       {
     auto copy = getFrameSet();
     copy->removeFrame(iframe);
     _update(*copy);
 }

◆ removeFrame() [2/2]

void ast::FrameDict::removeFrame ( std::string const & domain )

Variant of removeFrame(int) with the frame specified by domain.

Exceptions

std::out_of_range if no frame found with the specified domain

Definition at line 59 of file FrameDict.cc.

59 { removeFrame(getIndex(domain)); }

ast::FrameDict::removeFrame

int getIndex(std::string const &domain) const

Get the index of a frame specified by domain.

Definition: FrameDict.h:189

void removeFrame(int iframe) override

Remove a Frame from a FrameSet.

Definition: FrameDict.cc:53

◆ renameVariant()

void ast::FrameSet::renameVariant ( std::string const & name )

inlineinherited

Rename the current Variant of the current Mapping.

The Variant attribute is updated to name.

See the Variant attribute for more details. See also addVariant, getVariant and mirrorVariants.

Parameters

[in] name The new name of the current variant Mapping.

Exceptions

std::runtime_error

if:

A variant with the supplied name already exists in the current Frame.
The current Frame is a mirror for the variant Mappings in another Frame. This is only the case if the astMirrorVariants function has been called to make the current Frame act as a mirror.

Definition at line 463 of file FrameSet.h.

                                               {
         astAddVariant(getRawPtr(), nullptr, name.c_str());
         assertOK();
     }

◆ resolve()

ResolvedPoint ast::Frame::resolve	(	std::vector< double > const &	point1,
		std::vector< double > const &	point2,
		std::vector< double > const &	point3
	)		const

inherited

Resolve a vector into two orthogonal components.

The vector from point 1 to point 2 is used as the basis vector. The vector from point 1 to point 3 is resolved into components parallel and perpendicular to this basis vector. The lengths of the two components are returned, together with the position of closest aproach of the basis vector to point 3.

Parameters

[in]	point1	The start of the basis vector, and of the vector to be resolved.
[in]	point2	The end of the basis vector.
[in]	point3	The end of the vector to be resolved.

Returns

a ResolvedPoint containing:

point The point of closest approach of the basis vector to point 3.
d1 The distance from point 1 to the returned point (that is, the length of the component parallel to the basis vector). Positive values are in the same sense as movement from point 1 to point 2.
d2 The distance from the returned point to point 3 (that is, the length of the component perpendicular to the basis vector). The value is always positive.

Notes

Each vector used in this method is the path of shortest distance between two points, as defined by distance
This method will return nan coordinate values if any of the input coordinates are invalid, or if the required output values are undefined.

Definition at line 84 of file Frame.cc.

                                                                     {
     int const naxes = getNAxes();
     detail::assertEqual(point1.size(), "a1.size()", static_cast<std::size_t>(naxes), "");
     detail::assertEqual(point2.size(), "a2.size()", static_cast<std::size_t>(naxes), "");
     detail::assertEqual(point3.size(), "b1.size()", static_cast<std::size_t>(naxes), "");
     ResolvedPoint ret(naxes);
     astResolve(getRawPtr(), point1.data(), point2.data(), point3.data(), ret.point.data(), &ret.d1, &ret.d2);
     assertOK();
     detail::astBadToNan(ret.point);
     return ret;
 }

◆ same()

bool ast::Object::same ( Object const & other ) const

inlineinherited

Does this contain the same AST object as another?

This is a test of identity, not of equality.

Definition at line 212 of file Object.h.

212 { return astSame(getRawPtr(), other.getRawPtr()); }

ast::Object::getRawPtr

AstObject const * getRawPtr() const

Get the raw AST pointer.

Definition: Object.h:292

other

ItemVariant const * other

Definition: Schema.cc:56

◆ set()

void ast::Object::set ( std::string const & setting )

inlineprotectedinherited

Assign a set of attribute values, over-riding any previous values.

The attributes and their new values are specified via a character string, which should contain a comma-separated list of the form: "attribute_1 = value_1, attribute_2 = value_2, ... " where "attribute_n" specifies an attribute name, and the value to the right of each " =" sign should be a suitable textual representation of the value to be assigned. This value will be interpreted according to the attribute's data type.

Notes

Attribute names are not case sensitive and may be surrounded by white space
Attribute names are not case sensitive and may be surrounded by white space.
White space may also surround attribute values, where it will generally be ignored (except for string-valued attributes where it is significant and forms part of the value to be assigned).
To include a literal comma or percent sign in the value assigned to an attribute, the whole attribute value should be enclosed in quotation markes.

Exceptions

std::runtime_error if the attribute is read-only

Definition at line 440 of file Object.h.

                                        {
         astSet(getRawPtr(), "%s", setting.c_str());
         assertOK();
     }

◆ setActiveUnit()

void ast::Frame::setActiveUnit ( bool enable )

inlineinherited

Set ActiveUnit: pay attention to units when one Frame is used to match another?

Definition at line 1295 of file Frame.h.

                                     {
         astSetActiveUnit(getRawPtr(), enable);
         assertOK();
     }

◆ setAlignSystem()

void ast::Frame::setAlignSystem ( std::string const & system )

inlineinherited

Set AlignSystem: the coordinate system used by convert and findFrame to align Frames.

Definition at line 1203 of file Frame.h.

1203 { setC("AlignSystem", system); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

◆ setB()

void ast::Object::setB	(	std::string const &	attrib,
		bool	value
	)

inlineprotectedinherited

Set the value of an attribute as a bool.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 452 of file Object.h.

                                                    {
         astSetI(getRawPtr(), attrib.c_str(), value);
         assertOK();
     }

◆ setBase() [1/2]

void ast::FrameDict::setBase ( std::string const & domain )

inline

Variant of setBase(int) with the frame specified by domain.

Exceptions

std::out_of_range if no frame found with the specified domain

Definition at line 238 of file FrameDict.h.

238 { setBase(getIndex(domain)); }

int getIndex(std::string const &domain) const

Get the index of a frame specified by domain.

Definition: FrameDict.h:189

ast::FrameDict::setBase

void setBase(std::string const &domain)

Variant of setBase(int) with the frame specified by domain.

Definition: FrameDict.h:238

◆ setBase() [2/2]

void ast::FrameSet::setBase ( int ind )

inlineinherited

Set Base: index of base Frame.

Definition at line 471 of file FrameSet.h.

471 { setI("Base", ind); }

void setI(std::string const &attrib, int value)

Set the value of an attribute as an int.

Definition: Object.h:500

◆ setBottom()

void ast::Frame::setBottom	(	int	axis,
		double	bottom
	)

inlineinherited

Set Bottom: the lowest axis value to display.

Definition at line 1208 of file Frame.h.

1208 { setD(detail::formatAxisAttr("Bottom", axis), bottom); }

void setD(std::string const &attrib, double value)

Set the value of an attribute as a double.

Definition: Object.h:476

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

◆ setC()

void ast::Object::setC	(	std::string const &	attrib,
		std::string const &	value
	)

inlineprotectedinherited

Set the value of an attribute as a string.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 464 of file Object.h.

                                                                {
         astSetC(getRawPtr(), attrib.c_str(), value.c_str());
         assertOK();
     }

◆ setCurrent() [1/2]

void ast::FrameDict::setCurrent ( std::string const & domain )

inline

Variant of setCurrent(int) with the frame specified by domain.

Exceptions

std::out_of_range if no frame found with the specified domain

Definition at line 247 of file FrameDict.h.

247 { setCurrent(getIndex(domain)); }

ast::FrameDict::setCurrent

int getIndex(std::string const &domain) const

Get the index of a frame specified by domain.

Definition: FrameDict.h:189

void setCurrent(std::string const &domain)

Variant of setCurrent(int) with the frame specified by domain.

Definition: FrameDict.h:247

◆ setCurrent() [2/2]

void ast::FrameSet::setCurrent ( int ind )

inlineinherited

Set Current: index of current Frame, starting from 1.

Definition at line 476 of file FrameSet.h.

476 { setI("Current", ind); }

void setI(std::string const &attrib, int value)

Set the value of an attribute as an int.

Definition: Object.h:500

◆ setD()

void ast::Object::setD	(	std::string const &	attrib,
		double	value
	)

inlineprotectedinherited

Set the value of an attribute as a double.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 476 of file Object.h.

                                                      {
         astSetD(getRawPtr(), attrib.c_str(), value);
         assertOK();
     }

◆ setDigits() [1/2]

void ast::Frame::setDigits ( int digits )

inlineinherited

Set Digits for all axes: number of digits of precision.

Definition at line 1213 of file Frame.h.

1213 { setI("Digits", digits); }

void setI(std::string const &attrib, int value)

Set the value of an attribute as an int.

Definition: Object.h:500

◆ setDigits() [2/2]

void ast::Frame::setDigits	(	int	axis,
		int	digits
	)

inlineinherited

Set Digits for one axis: number of digits of precision.

Definition at line 1218 of file Frame.h.

1218 { setD(detail::formatAxisAttr("Digits", axis), digits); }

void setD(std::string const &attrib, double value)

Set the value of an attribute as a double.

Definition: Object.h:476

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

◆ setDirection()

void ast::Frame::setDirection	(	bool	direction,
		int	axis
	)

inlineinherited

Set Direction for one axis: display axis in conventional direction?

Definition at line 1223 of file Frame.h.

                                                 {
         setB(detail::formatAxisAttr("Direction", axis), direction);
     }

◆ setDomain()

void ast::FrameDict::setDomain ( std::string const & domain )

overridevirtual

Set the domain of the current frame (and update the internal dict).

Exceptions

std::invalid_argument if another frame already has this domain

Reimplemented from ast::Frame.

Definition at line 61 of file FrameDict.cc.

                                                  {
     if (getDomain() == domain) {
         // null rename
         return;
     }
     if (hasDomain(domain)) {
         throw std::invalid_argument("Another framea already has domain name " + domain);
     }
     auto copy = getFrameSet();
     copy->setDomain(domain);
     _update(*copy);
 }

◆ setDut1()

void ast::Frame::setDut1 ( double dut1 )

inlineinherited

Set Dut1: difference between the UT1 and UTC timescale (sec)

Definition at line 1235 of file Frame.h.

1235 { setD("Dut1", dut1); }

void setD(std::string const &attrib, double value)

Set the value of an attribute as a double.

Definition: Object.h:476

◆ setEpoch() [1/2]

void ast::Frame::setEpoch ( double epoch )

inlineinherited

Set Epoch: Epoch of observation as a double (years)

Definition at line 1240 of file Frame.h.

1240 { setD("Epoch", epoch); }

void setD(std::string const &attrib, double value)

Set the value of an attribute as a double.

Definition: Object.h:476

◆ setEpoch() [2/2]

void ast::Frame::setEpoch ( std::string const & epoch )

inlineinherited

Set Epoch: Epoch of observation as a string.

Definition at line 1245 of file Frame.h.

1245 { setC("Epoch", epoch); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

◆ setF()

void ast::Object::setF	(	std::string const &	attrib,
		float	value
	)

inlineprotectedinherited

Set the value of an attribute as a float.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 488 of file Object.h.

                                                     {
         astSetF(getRawPtr(), attrib.c_str(), value);
         assertOK();
     }

◆ setFormat()

void ast::Frame::setFormat	(	int	axis,
		std::string const &	format
	)

inlineinherited

Set Format for one axis: format specification for axis values.

Definition at line 1250 of file Frame.h.

                                                       {
         setC(detail::formatAxisAttr("Format", axis), format);
     }

◆ setI()

void ast::Object::setI	(	std::string const &	attrib,
		int	value
	)

inlineprotectedinherited

Set the value of an attribute as an int.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 500 of file Object.h.

                                                   {
         astSetI(getRawPtr(), attrib.c_str(), value);
         assertOK();
     }

◆ setID()

void ast::Object::setID ( std::string const & id )

inlineinherited

Set ID: object identification string that is not copied.

Definition at line 215 of file Object.h.

215 { setC("ID", id); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

◆ setIdent()

void ast::Object::setIdent ( std::string const & ident )

inlineinherited

Set Ident: object identification string that is copied.

Definition at line 218 of file Object.h.

218 { setC("Ident", ident); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

◆ setL()

void ast::Object::setL	(	std::string const &	attrib,
		long int	value
	)

inlineprotectedinherited

Set the value of an attribute as a long int.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error if the attribute does not exist or the value cannot be converted

Definition at line 512 of file Object.h.

                                                        {
         astSetL(getRawPtr(), attrib.c_str(), value);
         assertOK();
     }

◆ setLabel()

void ast::Frame::setLabel	(	int	axis,
		std::string const &	label
	)

inlineinherited

Set Label(axis) for one axis: axis label.

Definition at line 1257 of file Frame.h.

1257 { setC(detail::formatAxisAttr("Label", axis), label); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

◆ setMatchEnd()

void ast::Frame::setMatchEnd ( bool match )

inlineinherited

Set MatchEnd: match trailing axes?

Definition at line 1262 of file Frame.h.

1262 { setB("MatchEnd", match); }

void setB(std::string const &attrib, bool value)

Set the value of an attribute as a bool.

Definition: Object.h:452

◆ setMaxAxes()

void ast::Frame::setMaxAxes ( int maxAxes )

inlineinherited

Get MaxAxes: the maximum number of axes a frame found by findFrame may have.

Definition at line 1268 of file Frame.h.

1268 { setI("MaxAxes", maxAxes); }

void setI(std::string const &attrib, int value)

Set the value of an attribute as an int.

Definition: Object.h:500

◆ setMinAxes()

void ast::Frame::setMinAxes ( int minAxes )

inlineinherited

Get MinAxes: the minimum number of axes a frame found by findFrame may have.

Definition at line 1274 of file Frame.h.

1274 { setI("MinAxes", minAxes); }

void setI(std::string const &attrib, int value)

Set the value of an attribute as an int.

Definition: Object.h:500

◆ setObsAlt()

void ast::Frame::setObsAlt ( double alt )

inlineinherited

Set ObsAlt: Geodetic altitude of observer (m).

Definition at line 1279 of file Frame.h.

1279 { setD("ObsAlt", alt); }

void setD(std::string const &attrib, double value)

Set the value of an attribute as a double.

Definition: Object.h:476

◆ setObsLat()

void ast::Frame::setObsLat ( std::string const & lat )

inlineinherited

Set ObsLat: frame title.

Definition at line 1284 of file Frame.h.

1284 { setC("ObsLat", lat); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

◆ setObsLon()

void ast::Frame::setObsLon ( std::string const & lon )

inlineinherited

Set ObsLon: Geodetic longitude of observer.

Definition at line 1289 of file Frame.h.

1289 { setC("ObsLon", lon); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

◆ setPermute()

void ast::Frame::setPermute ( bool permute )

inlineinherited

Set Permute: allow axis permutation when used as a template?

Definition at line 1303 of file Frame.h.

1303 { setB("Permute", permute); }

void setB(std::string const &attrib, bool value)

Set the value of an attribute as a bool.

Definition: Object.h:452

◆ setPreserveAxes()

void ast::Frame::setPreserveAxes ( bool preserve )

inlineinherited

Set PreserveAxes: preserve axes?

Definition at line 1308 of file Frame.h.

1308 { setB("PreserveAxes", preserve); }

void setB(std::string const &attrib, bool value)

Set the value of an attribute as a bool.

Definition: Object.h:452

◆ setReport()

void ast::Mapping::setReport ( bool report )

inlineinherited

Set Report: report transformed coordinates to stdout?

Definition at line 225 of file Mapping.h.

225 { setB("Report", report); }

void setB(std::string const &attrib, bool value)

Set the value of an attribute as a bool.

Definition: Object.h:452

◆ setSymbol()

void ast::Frame::setSymbol	(	int	axis,
		std::string const &	symbol
	)

inlineinherited

Set Symbol(axis) for one axis: axis symbol.

Definition at line 1313 of file Frame.h.

                                                       {
         setC(detail::formatAxisAttr("Symbol", axis), symbol);
     }

◆ setSystem()

void ast::Frame::setSystem ( std::string const & system )

inlineinherited

Set System: coordinate system used to describe positions within the domain.

Definition at line 1321 of file Frame.h.

1321 { setC("System", system); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

◆ setTitle()

void ast::Frame::setTitle ( std::string const & title )

inlineinherited

Set Title: frame title.

Definition at line 1326 of file Frame.h.

1326 { setC("Title", title); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

◆ setTop()

void ast::Frame::setTop	(	int	axis,
		double	top
	)

inlineinherited

Set Top for one axis: the highest axis value to display.

Definition at line 1331 of file Frame.h.

1331 { setD(detail::formatAxisAttr("Top", axis), top); }

void setD(std::string const &attrib, double value)

Set the value of an attribute as a double.

Definition: Object.h:476

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

◆ setUnit()

void ast::Frame::setUnit	(	int	axis,
		std::string const &	unit
	)

inlineinherited

Set Unit(axis) for one axis: physical units for formatted axis values.

Definition at line 1336 of file Frame.h.

1336 { setC(detail::formatAxisAttr("Unit", axis), unit); }

void setC(std::string const &attrib, std::string const &value)

Set the value of an attribute as a string.

Definition: Object.h:464

std::string formatAxisAttr(std::string const &name, int axis)

Format an axis-specific attribute by appending the axis index.

Definition: utils.h:79

◆ setUseDefs()

void ast::Object::setUseDefs ( bool usedefs )

inlineinherited

Set UseDefs: allow use of default values for Object attributes?

Definition at line 221 of file Object.h.

221 { setB("UseDefs", usedefs); }