lsst::afw::geom::Transform< FromEndpoint, ToEndpoint > Class Template Reference

Transform LSST spatial data, such as lsst::geom::Point2D and lsst::geom::SpherePoint, using an AST mapping. More...

#include <Transform.h>

Inheritance diagram for lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >:

Public Types
using	FromArray = typename FromEndpoint::Array
using	FromPoint = typename FromEndpoint::Point
using	ToArray = typename ToEndpoint::Array
using	ToPoint = typename ToEndpoint::Point

Public Member Functions
	Transform (Transform const &)=default
	Transform (Transform &&)=default
Transform &	operator= (Transform const &)=delete
Transform &	operator= (Transform &&)=delete
	~Transform () override=default
	Transform (ast::Mapping const &mapping, bool simplify=true)
	Construct a Transform from a deep copy of an ast::Mapping. More...
	Transform (ast::FrameSet const &frameSet, bool simplify=true)
	Construct a Transform from a deep copy of a ast::FrameSet. More...
bool	hasForward () const
	Test if this method has a forward transform. More...
bool	hasInverse () const
	Test if this method has an inverse transform. More...
FromEndpoint	getFromEndpoint () const
	Get the "from" endpoint. More...
std::shared_ptr< const ast::Mapping >	getMapping () const
	Get the contained mapping. More...
ToEndpoint	getToEndpoint () const
	Get the "to" endpoint. More...
ToPoint	applyForward (FromPoint const &point) const
	Transform one point in the forward direction ("from" to "to") More...
ToArray	applyForward (FromArray const &array) const
	Transform an array of points in the forward direction ("from" to "to") More...
FromPoint	applyInverse (ToPoint const &point) const
	Transform one point in the inverse direction ("to" to "from") More...
FromArray	applyInverse (ToArray const &array) const
	Transform an array of points in the inverse direction ("to" to "from") More...
std::shared_ptr< Transform< ToEndpoint, FromEndpoint > >	inverted () const
	The inverse of this Transform. More...
Eigen::MatrixXd	getJacobian (FromPoint const &x) const
	The Jacobian matrix of this Transform. More...
template<class NextToEndpoint >
std::shared_ptr< Transform< FromEndpoint, NextToEndpoint > >	then (Transform< ToEndpoint, NextToEndpoint > const &next, bool simplify=true) const
	Concatenate two Transforms. More...
void	writeStream (std::ostream &os) const
	Serialize this Transform to an output stream. More...
std::string	writeString () const
	Serialize this Transform to a string, using the same format as writeStream. More...
bool	isPersistable () const noexcept override
	Whether the Transform is persistable via afw::table::io (always true). More...
void	writeFits (std::string const &fileName, std::string const &mode="w") const
	Write the object to a regular FITS file. More...
void	writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
	Write the object to a FITS image in memory. More...
void	writeFits (fits::Fits &fitsfile) const
	Write the object to an already-open FITS object. More...

Static Public Member Functions
static std::string	getShortClassName ()
	Return a short version of the class name with no punctuation. More...
static std::shared_ptr< Transform< FromEndpoint, ToEndpoint > >	readStream (std::istream &is)
	Deserialize a Transform of this type from an input stream. More...
static std::shared_ptr< Transform< FromEndpoint, ToEndpoint > >	readString (std::string &str)
	Deserialize a Transform of this type from a string, using the same format as readStream. More...
static std::shared_ptr< Transform< FromEndpoint, ToEndpoint > >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object. More...
static std::shared_ptr< Transform< FromEndpoint, ToEndpoint > >	readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
	Read an object from a regular FITS file. More...
static std::shared_ptr< Transform< FromEndpoint, ToEndpoint > >	readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
	Read an object from a FITS file in memory. More...
static std::shared_ptr< Transform< FromEndpoint, ToEndpoint > >	dynamicCast (std::shared_ptr< Persistable > const &ptr)
	Dynamically cast a shared_ptr. More...

Protected Types
typedef io::OutputArchiveHandle	OutputArchiveHandle

Protected Member Functions
	Transform (std::shared_ptr< ast::Mapping > mapping)
	Construct a Transform from a shared pointer to an ast::Mapping. More...
std::string	getPersistenceName () const override
	Return the unique name used to persist this object and look up its factory. More...
std::string	getPythonModule () const override
	Return the fully-qualified Python module that should be imported to guarantee that its factory is registered. More...
void	write (OutputArchiveHandle &handle) const override
	Write the object to one or more catalogs. More...

Friends
class	SkyWcs

Detailed Description

template<class FromEndpoint, class ToEndpoint>
class lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >

Transform LSST spatial data, such as lsst::geom::Point2D and lsst::geom::SpherePoint, using an AST mapping.

This class contains two Endpoints, to specify the "from" and "to" LSST data type, and an ast::Mapping to specify the transformation.

Depending on the ast::FrameSet or ast::Mapping used to define it, a Transform may provide either a forward transform, an inverse transform, or both. In particular, the inverse of a forward-only transform is an inverse-only transform. The hasForward and hasInverse methods can be used to check which transforms are available.

Unless otherwise stated, all constructors and methods may throw std::runtime_error to indicate internal errors within AST.

Transforms are always immutable.

Note

You gain some safety by constructing a Transform from an ast::FrameSet, since the base and current frames in the FrameSet can be checked against by the appropriate endpoint.

"In place" versions of applyForward and applyInverse are not available because data must be copied when converting from LSST data types to the type used by astshim, so it didn't seem worth the bother.

Definition at line 67 of file Transform.h.

Member Typedef Documentation

FromArray

template<class FromEndpoint, class ToEndpoint>

using lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::FromArray = typename FromEndpoint::Array

Definition at line 73 of file Transform.h.

FromPoint

template<class FromEndpoint, class ToEndpoint>

using lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::FromPoint = typename FromEndpoint::Point

Definition at line 74 of file Transform.h.

OutputArchiveHandle

typedef io::OutputArchiveHandle lsst::afw::table::io::Persistable::OutputArchiveHandle

protectedinherited

Definition at line 108 of file Persistable.h.

ToArray

template<class FromEndpoint, class ToEndpoint>

using lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::ToArray = typename ToEndpoint::Array

Definition at line 75 of file Transform.h.

ToPoint

template<class FromEndpoint, class ToEndpoint>

using lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::ToPoint = typename ToEndpoint::Point

Definition at line 76 of file Transform.h.

Constructor & Destructor Documentation

Transform() [1/5]

template<class FromEndpoint, class ToEndpoint>

lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::Transform ( Transform< FromEndpoint, ToEndpoint > const &  )

default

Transform() [2/5]

template<class FromEndpoint, class ToEndpoint>

lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::Transform ( Transform< FromEndpoint, ToEndpoint > &&  )

default

~Transform()

template<class FromEndpoint, class ToEndpoint>

lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::~Transform ( )

overridedefault

Transform() [3/5]

template<class FromEndpoint , class ToEndpoint >

lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::Transform ( ast::Mapping const &  mapping, bool  simplify = true  )

explicit

Construct a Transform from a deep copy of an ast::Mapping.

Parameters

[in]	mapping	ast::Mapping describing the desired transformation
[in]	simplify	Simplify the mapping? This combines component mappings where it is possible to do so without affecting accuracy.

Definition at line 45 of file Transform.cc.

        : _fromEndpoint(mapping.getNIn()),
          _mapping(simplify ? mapping.simplified() : mapping.copy()),
          _toEndpoint(mapping.getNOut()) {}

Transform() [4/5]

template<typename FromEndpoint , typename ToEndpoint >

lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::Transform ( ast::FrameSet const &  frameSet, bool  simplify = true  )

explicit

Construct a Transform from a deep copy of a ast::FrameSet.

The result transforms from the "base" frame to the "current" frame of the provided FrameSet. The "from" endpoint is used to normalize the "base" frame and the "to" endpoint is used to normalize the "current" frame.

This is pickier than the constructor that takes an ast::Mapping in that:

• SpherePointEndpoint must be associated with an ast::SkyFrame and the SkyFrame axes are transposed, if necessary, to give the standard order: longitude, latitude.
• Point2Endpoint must be associated with an ast::Frame (not a subclass), because Frame is the only kind of Frame that is sure to be Cartesian.

Parameters

[in]	frameSet	ast::FrameSet describing the desired transformation in the usual way: from "base" frame to "current" frame
[in]	simplify	Simplify the mapping? This combines component mappings where it is possible to do so without affecting accuracy.

Definition at line 51 of file Transform.cc.

        : _fromEndpoint(frameSet.getNIn()), _mapping(), _toEndpoint(frameSet.getNOut()) {
    auto frameSetCopy = frameSet.copy();
    // Normalize the base and current frame in a way that affects its behavior as a mapping.
    // To do this one must set the current frame to the frame to be normalized
    // and normalize the frame set as a frame (i.e. normalize the frame "in situ").
    // The obvious alternative of normalizing a shallow copy of the frame does not work;
    // the frame is altered but not the associated mapping!

    // Normalize the current frame by normalizing the frameset as a frame
    _toEndpoint.normalizeFrame(frameSetCopy);

    // Normalize the base frame by temporarily making it the current frame,
    // normalizing the frameset as a frame, then making it the base frame again
    const int baseIndex = frameSetCopy->getBase();
    const int currentIndex = frameSetCopy->getCurrent();
    frameSetCopy->setCurrent(baseIndex);
    _fromEndpoint.normalizeFrame(frameSetCopy);
    frameSetCopy->setBase(baseIndex);
    frameSetCopy->setCurrent(currentIndex);
    _mapping = simplify ? frameSetCopy->getMapping()->simplified() : frameSetCopy->getMapping();
}

Transform() [5/5]

template<typename FromEndpoint , typename ToEndpoint >

lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::Transform ( std::shared_ptr< ast::Mapping >  mapping )

explicitprotected

Construct a Transform from a shared pointer to an ast::Mapping.

Definition at line 75 of file Transform.cc.

        : _fromEndpoint(mapping->getNIn()), _mapping(mapping), _toEndpoint(mapping->getNOut()) {}

Member Function Documentation

applyForward() [1/2]

template<class FromEndpoint , class ToEndpoint >

ToEndpoint::Point lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::applyForward

(

FromPoint const &

point

)

const

Transform one point in the forward direction ("from" to "to")

Definition at line 79 of file Transform.cc.

                                                       {
    auto const rawFromData = _fromEndpoint.dataFromPoint(point);
    auto rawToData = _mapping->applyForward(rawFromData);
    return _toEndpoint.pointFromData(rawToData);
}

applyForward() [2/2]

template<class FromEndpoint , class ToEndpoint >

ToEndpoint::Array lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::applyForward

(

FromArray const &

array

)

const

Transform an array of points in the forward direction ("from" to "to")

The first dimension of the array must match the number of input axes, and the data order is values for the first axis, then values for the next axis, and so on, e.g. for 2 axes: x0, x1, x2, ..., y0, y1, y2...

Definition at line 87 of file Transform.cc.

                                                       {
    auto const rawFromData = _fromEndpoint.dataFromArray(array);
    auto rawToData = _mapping->applyForward(rawFromData);
    return _toEndpoint.arrayFromData(rawToData);
}

applyInverse() [1/2]

template<class FromEndpoint , class ToEndpoint >

FromEndpoint::Point lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::applyInverse

(

ToPoint const &

point

)

const

Transform one point in the inverse direction ("to" to "from")

Definition at line 95 of file Transform.cc.

                                                     {
    auto const rawFromData = _toEndpoint.dataFromPoint(point);
    auto rawToData = _mapping->applyInverse(rawFromData);
    return _fromEndpoint.pointFromData(rawToData);
}

applyInverse() [2/2]

template<class FromEndpoint , class ToEndpoint >

FromEndpoint::Array lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::applyInverse

(

ToArray const &

array

)

const

Transform an array of points in the inverse direction ("to" to "from")

The first dimension of the array must match the number of output axes, and the data order is values for the first axis, then values for the next axis, and so on, e.g. for 2 axes: x0, x1, x2, ..., y0, y1, y2...

Definition at line 103 of file Transform.cc.

                                                     {
    auto const rawFromData = _toEndpoint.dataFromArray(array);
    auto rawToData = _mapping->applyInverse(rawFromData);
    return _fromEndpoint.arrayFromData(rawToData);
}

dynamicCast()

template std::shared_ptr< meas::extensions::psfex::PsfexPsf > lsst::afw::table::io::PersistableFacade< Transform< FromEndpoint, ToEndpoint > >::dynamicCast ( std::shared_ptr< Persistable > const &  ptr )

staticinherited

Dynamically cast a shared_ptr.

Dynamically cast a shared pointer and raise on failure.

You must provide an explicit template instantiation in the .cc file for each class that inherits from PersistableFacade. Designed to work around RTTI issues on macOS with hidden symbols;

Exceptions

lsst::pex::exceptions::LogicError

if the cast fails

param[in] ptr The pointer to be cast.

Returns

The cast pointer.

Exceptions

lsst::pex::exceptions::TypeError

If the dynamic cast fails.

Definition at line 18 of file Persistable.cc.

                                                                                        {
    auto result = std::dynamic_pointer_cast<T>(ptr);
    if (!result) {
        throw LSST_EXCEPT(pex::exceptions::TypeError, "Dynamic pointer cast failed");
    }
    return result;
}

getFromEndpoint()

template<class FromEndpoint, class ToEndpoint>

FromEndpoint lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::getFromEndpoint ( ) const

inline

Get the "from" endpoint.

Definition at line 130 of file Transform.h.

{ return _fromEndpoint; }

getJacobian()

template<class FromEndpoint , class ToEndpoint >

Eigen::MatrixXd lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::getJacobian

(

FromPoint const &

x

)

const

The Jacobian matrix of this Transform.

Radians are used for each axis of an SpherePointEndpoint.

The matrix is defined only if this object has a forward transform.

Parameters

x	the position at which the Jacobian shall be evaluated

Returns

a matrix J with getToEndpoint().getNAxes() rows and getFromEndpoint().getNAxes() columns. J(i,j) shall be the rate of change of the ith output coordinate with respect to the jth input coordinate, or NaN if the derivative cannot be calculated.

Exception Safety

Provides basic exception safety.

Note

The derivatives may be estimated by sampling and interpolating this Transform in the neighborhood of x. If the implementation requires interpolation, computation of the Jacobian may require hundreds of evaluations of applyForward.

Definition at line 123 of file Transform.cc.

                                                                                       {
    int const nIn = _fromEndpoint.getNAxes();
    int const nOut = _toEndpoint.getNAxes();
    std::vector<double> const point = _fromEndpoint.dataFromPoint(x);

    Eigen::MatrixXd jacobian(nOut, nIn);
    for (int i = 0; i < nOut; ++i) {
        for (int j = 0; j < nIn; ++j) {
            jacobian(i, j) = _mapping->rate(point, i + 1, j + 1);
        }
    }
    return jacobian;
}

getMapping()

template<class FromEndpoint, class ToEndpoint>

std::shared_ptr<const ast::Mapping> lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::getMapping ( ) const

inline

Get the contained mapping.

Definition at line 135 of file Transform.h.

{ return _mapping; }

getPersistenceName()

template<class FromEndpoint, class ToEndpoint>

std::string lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::getPersistenceName ( ) const

inlineoverrideprotectedvirtual

Return the unique name used to persist this object and look up its factory.

Must be less than ArchiveIndexSchema::MAX_NAME_LENGTH characters.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 274 of file Transform.h.

{ return getShortClassName(); }

getPythonModule()

template<class FromEndpoint, class ToEndpoint>

std::string lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::getPythonModule ( ) const

inlineoverrideprotectedvirtual

Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

Must be less than ArchiveIndexSchema::MAX_MODULE_LENGTH characters.

Will be ignored if empty.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 277 of file Transform.h.

{ return "lsst.afw.geom"; }

getShortClassName()

template<class FromEndpoint , class ToEndpoint >

std::string lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::getShortClassName ( )

static

Return a short version of the class name with no punctuation.

Used as the Python class name and for persistence as a string

Returns "Transform" + fromEndpoint.getClassPrefix() + "To" + toEndpoint.getClassPrefix(), for example "TransformPoint2ToSpherePoint" or "TransformPoint2ToGeneric".

Definition at line 138 of file Transform.cc.

                                                                 {
    std::ostringstream os;
    os << "Transform" << FromEndpoint::getClassPrefix() << "To" << ToEndpoint::getClassPrefix();
    return os.str();
}

getToEndpoint()

template<class FromEndpoint, class ToEndpoint>

ToEndpoint lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::getToEndpoint ( ) const

inline

Get the "to" endpoint.

Definition at line 140 of file Transform.h.

{ return _toEndpoint; }

hasForward()

template<class FromEndpoint, class ToEndpoint>

bool lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::hasForward ( ) const

inline

Test if this method has a forward transform.

Exception Safety

Provides basic exception safety.

Definition at line 118 of file Transform.h.

{ return _mapping->hasForward(); }

hasInverse()

template<class FromEndpoint, class ToEndpoint>

bool lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::hasInverse ( ) const

inline

Test if this method has an inverse transform.

Exception Safety

Provides basic exception safety.

Definition at line 125 of file Transform.h.

{ return _mapping->hasInverse(); }

inverted()

template<class FromEndpoint , class ToEndpoint >

std::shared_ptr< Transform< ToEndpoint, FromEndpoint > > lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::inverted

(

)

const

The inverse of this Transform.

Returns

a Transform whose applyForward is equivalent to this Transform's applyInverse, and vice versa.

Exception Safety

Provides basic exception safety.

Definition at line 111 of file Transform.cc.

                                                                                                       {
    auto inverse = std::dynamic_pointer_cast<ast::Mapping>(_mapping->inverted());
    if (!inverse) {
        // don't throw std::bad_cast because it doesn't let you provide debugging info
        std::ostringstream buffer;
        buffer << "Mapping.inverted() does not return a Mapping. Called from: " << _mapping;
        throw LSST_EXCEPT(pex::exceptions::LogicError, buffer.str());
    }
    return std::make_shared<Transform<ToEndpoint, FromEndpoint>>(*inverse);
}

isPersistable()

template<class FromEndpoint, class ToEndpoint>

bool lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::isPersistable ( ) const

inlineoverridevirtualnoexcept

Whether the Transform is persistable via afw::table::io (always true).

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 265 of file Transform.h.

{ return true; }

operator=() [1/2]

template<class FromEndpoint, class ToEndpoint>

Transform& lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::operator= ( Transform< FromEndpoint, ToEndpoint > const &  )

delete

operator=() [2/2]

template<class FromEndpoint, class ToEndpoint>

Transform& lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::operator= ( Transform< FromEndpoint, ToEndpoint > &&  )

delete

readFits() [1/3]

static std::shared_ptr<Transform< FromEndpoint, ToEndpoint > > lsst::afw::table::io::PersistableFacade< Transform< FromEndpoint, ToEndpoint > >::readFits ( fits::Fits &  fitsfile )

inlinestaticinherited

Read an object from an already open FITS object.

Parameters

[in]

fitsfile

FITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

                                                         {
        return dynamicCast(Persistable::_readFits(fitsfile));
    }

readFits() [2/3]

static std::shared_ptr<Transform< FromEndpoint, ToEndpoint > > lsst::afw::table::io::PersistableFacade< Transform< FromEndpoint, ToEndpoint > >::readFits ( std::string const &  fileName, int  hdu = fits::DEFAULT_HDU  )

inlinestaticinherited

Read an object from a regular FITS file.

Parameters

[in]	fileName	Name of the file to read.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 194 of file Persistable.h.

                                                                                           {
        return dynamicCast(Persistable::_readFits(fileName, hdu));
    }

readFits() [3/3]

static std::shared_ptr<Transform< FromEndpoint, ToEndpoint > > lsst::afw::table::io::PersistableFacade< Transform< FromEndpoint, ToEndpoint > >::readFits ( fits::MemFileManager &  manager, int  hdu = fits::DEFAULT_HDU  )

inlinestaticinherited

Read an object from a FITS file in memory.

Parameters

[in]	manager	Manager for the memory to read from.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 205 of file Persistable.h.

                                                                                             {
        return dynamicCast(Persistable::_readFits(manager, hdu));
    }

readStream()

template<class FromEndpoint , class ToEndpoint >

std::shared_ptr< Transform< FromEndpoint, ToEndpoint > > lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::readStream ( std::istream &  is )

static

Deserialize a Transform of this type from an input stream.

Parameters

[in]

is

input stream from which to deserialize this Transform

Definition at line 145 of file Transform.cc.

                        {
    return detail::readStream<Transform<FromEndpoint, ToEndpoint>>(is);
}

readString()

template<class FromEndpoint , class ToEndpoint >

std::shared_ptr< Transform< FromEndpoint, ToEndpoint > > lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::readString ( std::string &  str )

static

Deserialize a Transform of this type from a string, using the same format as readStream.

Definition at line 151 of file Transform.cc.

                        {
    std::istringstream is(str);
    return Transform<FromEndpoint, ToEndpoint>::readStream(is);
}

then()

template<class FromEndpoint , class ToEndpoint>

template<class NextToEndpoint >

template std::shared_ptr< Transform< SpherePointEndpoint, SpherePointEndpoint > > lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::then< SpherePointEndpoint >	(	Transform< ToEndpoint, NextToEndpoint > const &	next,
		bool	simplify = true
	)		const

Concatenate two Transforms.

Template Parameters

NextToEndpoint

the "to" Endpoint of next

Parameters

next	the Transform to apply after this one
simplify	if true then produce a transform containing a single simplified mapping with no intermediate frames.

Returns

a Transform that first applies this transform to its input, and then next to the result. Its inverse shall first apply the inverse of next, and then the inverse of this transform.

Exceptions

pex::exceptions::InvalidParameterError

Thrown if getToEndpoint() and next.getFromEndpoint() do not have the same number of axes.

Exception Safety

Provides basic exception safety.

More than two Transforms can be combined in series. For example:

auto pixelsToSky = pixelsToFp.then(fpToField)->then(fieldToSky);

Definition at line 171 of file Transform.cc.

                                                                                {
    if (_toEndpoint.getNAxes() == next.getFromEndpoint().getNAxes()) {
        auto nextMapping = next.getMapping();
        auto combinedMapping = getMapping()->then(*next.getMapping());
        if (simplify) {
            return std::make_shared<Transform<FromEndpoint, NextToEndpoint>>(*combinedMapping.simplified());
        } else {
            return std::make_shared<Transform<FromEndpoint, NextToEndpoint>>(combinedMapping);
        }
    } else {
        auto message = "Cannot match " + std::to_string(_toEndpoint.getNAxes()) + "-D to-endpoint to " +
                       std::to_string(next.getFromEndpoint().getNAxes()) + "-D from-endpoint.";
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, message);
    }
}

write()

template<class FromEndpoint , class ToEndpoint >

void lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::write ( OutputArchiveHandle &  handle ) const

overrideprotectedvirtual

Write the object to one or more catalogs.

The handle object passed to this function provides an interface for adding new catalogs and adding nested objects to the same archive (while checking for duplicates). See OutputArchiveHandle for more information.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 241 of file Transform.cc.

                                                                                 {
    auto const &keys = TransformPersistenceHelper::get();
    table::BaseCatalog cat = handle.makeCatalog(keys.schema);
    std::shared_ptr<table::BaseRecord> record = cat.addNew();
    record->set(keys.bytes, formatters::stringToBytes(writeString()));
    handle.saveCatalog(cat);
}

writeFits() [1/3]

void lsst::afw::table::io::Persistable::writeFits ( std::string const &  fileName, std::string const &  mode = "w"  ) const

inherited

Write the object to a regular FITS file.

Parameters

[in]	fileName	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 24 of file Persistable.cc.

                                                                                  {
    fits::Fits fitsfile(fileName, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

writeFits() [2/3]

void lsst::afw::table::io::Persistable::writeFits ( fits::MemFileManager &  manager, std::string const &  mode = "w"  ) const

inherited

Write the object to a FITS image in memory.

Parameters

[in]	manager	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 29 of file Persistable.cc.

                                                                                    {
    fits::Fits fitsfile(manager, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

writeFits() [3/3]

void lsst::afw::table::io::Persistable::writeFits ( fits::Fits &  fitsfile ) const

inherited

Write the object to an already-open FITS object.

Parameters

[in]

fitsfile

Open FITS object to write to.

Definition at line 18 of file Persistable.cc.

                                                    {
    OutputArchive archive;
    archive.put(this);
    archive.writeFits(fitsfile);
}

writeStream()

template<class FromEndpoint , class ToEndpoint >

void lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::writeStream

(

std::ostream &

os

)

const

Serialize this Transform to an output stream.

Version 1 format is as follows:

• The version number (an integer)
• A space
• The short class name, as obtained from getShortClassName
• A space
• The contained ast::FrameSet written using FrameSet.show(os, false)

Parameters

[out]

os

outpu stream to which to serialize this Transform

Definition at line 158 of file Transform.cc.

                                                                          {
    detail::writeStream<Transform<FromEndpoint, ToEndpoint>>(*this, os);
}

writeString()

template<class FromEndpoint , class ToEndpoint >

std::string lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >::writeString

(

)

const

Serialize this Transform to a string, using the same format as writeStream.

Definition at line 163 of file Transform.cc.

                                                                 {
    std::ostringstream os;
    writeStream(os);
    return os.str();
}

Friends And Related Function Documentation

SkyWcs

template<class FromEndpoint, class ToEndpoint>

friend class SkyWcs

friend

Definition at line 70 of file Transform.h.

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/Linux64/afw/19.0.0-4-ga671dab3b+1/include/lsst/afw/geom/Transform.h
• /j/snowflake/release/lsstsw/stack/Linux64/afw/19.0.0-4-ga671dab3b+1/src/geom/Transform.cc