lsst::afw::geom::SkyWcs Class Reference

A 2-dimensional celestial WCS that transform pixels to ICRS RA/Dec, using the LSST standard for pixels. More...

#include <SkyWcs.h>

Inheritance diagram for lsst::afw::geom::SkyWcs:

Public Member Functions
	SkyWcs (SkyWcs const &)=default
	SkyWcs (SkyWcs &&)=default
SkyWcs &	operator= (SkyWcs const &)=delete
SkyWcs &	operator= (SkyWcs &&)=delete
	~SkyWcs () override=default
bool	operator== (SkyWcs const &other) const
	Equality is based on the string representations being equal.
bool	operator!= (SkyWcs const &other) const
	SkyWcs (daf::base::PropertySet &metadata, bool strip=false)
	Construct a SkyWcs from FITS keywords.
	SkyWcs (ast::FrameDict const &frameDict)
	Construct a SkyWcs from an ast::FrameDict.
std::shared_ptr< SkyWcs >	copyAtShiftedPixelOrigin (lsst::geom::Extent2D const &shift) const
	Return a copy of this SkyWcs with the pixel origin shifted by the specified amount.
std::shared_ptr< daf::base::PropertyList >	getFitsMetadata (bool precise=false) const
	Return the WCS as FITS WCS metadata.
lsst::geom::Angle	getPixelScale (lsst::geom::Point2D const &pixel) const
	Get the pixel scale at the specified pixel position.
lsst::geom::Angle	getPixelScale () const
	Get the pixel scale at the pixel origin.
lsst::geom::Point2D	getPixelOrigin () const
	Get the pixel origin, in pixels, using the LSST convention.
lsst::geom::SpherePoint	getSkyOrigin () const
	Get the sky origin, the celestial fiducial point.
Eigen::Matrix2d	getCdMatrix (lsst::geom::Point2D const &pixel) const
	Get the 2x2 CD matrix at the specified pixel position.
Eigen::Matrix2d	getCdMatrix () const
	Get the 2x2 CD matrix at the pixel origin.
std::shared_ptr< SkyWcs >	getTanWcs (lsst::geom::Point2D const &pixel) const
	Get a local TAN WCS approximation to this WCS at the specified pixel position.
std::shared_ptr< const ast::FrameDict >	getFrameDict () const
	Get the contained FrameDict.
std::shared_ptr< const TransformPoint2ToSpherePoint >	getTransform () const
	Get a TransformPoint2ToSpherePoint that transforms pixels to sky in the forward direction and sky to pixels in the inverse direction.
bool	isFlipped () const
	Does the WCS follow the convention of North=Up, East=Left?
bool	isPersistable () const noexcept override
	Return true if this particular object can be persisted using afw::table::io.
lsst::geom::AffineTransform	linearizePixelToSky (lsst::geom::SpherePoint const &coord, lsst::geom::AngleUnit const &skyUnit) const
	Return the local linear approximation to pixelToSky at a point given in sky coordinates.
lsst::geom::AffineTransform	linearizePixelToSky (lsst::geom::Point2D const &pixel, lsst::geom::AngleUnit const &skyUnit) const
	Return the local linear approximation to pixelToSky at a point given in pixel coordinates.
lsst::geom::AffineTransform	linearizeSkyToPixel (lsst::geom::SpherePoint const &coord, lsst::geom::AngleUnit const &skyUnit) const
	Return the local linear approximation to skyToPixel at a point given in sky coordinates.
lsst::geom::AffineTransform	linearizeSkyToPixel (lsst::geom::Point2D const &pixel, lsst::geom::AngleUnit const &skyUnit) const
	Return the local linear approximation to skyToPixel at a point given in pixel coordinates.
lsst::geom::SpherePoint	pixelToSky (lsst::geom::Point2D const &pixel) const
	Compute sky position(s) from pixel position(s)
lsst::geom::SpherePoint	pixelToSky (double x, double y) const
std::vector< lsst::geom::SpherePoint >	pixelToSky (std::vector< lsst::geom::Point2D > const &pixels) const
lsst::geom::Point2D	skyToPixel (lsst::geom::SpherePoint const &sky) const
	Compute pixel position(s) from sky position(s)
std::vector< lsst::geom::Point2D >	skyToPixel (std::vector< lsst::geom::SpherePoint > const &sky) const
bool	hasFitsApproximation () const
	Does this SkyWcs have an approximate SkyWcs that can be represented as standard FITS WCS?
bool	isFits () const
	Return true getFitsMetadata(true) will succeed, false if not.
void	writeStream (std::ostream &os) const
	Serialize this SkyWcs to an output stream.
std::string	writeString () const
	Serialize this SkyWcs to a string, using the same format as writeStream.
std::shared_ptr< typehandling::Storable >	cloneStorable () const override
	Create a new SkyWcs that is a copy of this one.
std::string	toString () const override
	Create a string representation of this object.
bool	equals (typehandling::Storable const &other) const noexcept override
	Compare this object to another Storable.
virtual std::size_t	hash_value () const
	Return a hash of this object (optional operation).
void	writeFits (std::string const &fileName, std::string const &mode="w") const
	Write the object to a regular FITS file.
void	writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
	Write the object to a FITS image in memory.
void	writeFits (fits::Fits &fitsfile) const
	Write the object to an already-open FITS object.

Static Public Member Functions
static std::string	getShortClassName ()
static std::shared_ptr< SkyWcs >	readStream (std::istream &is)
	Deserialize a SkyWcs from an input stream.
static std::shared_ptr< SkyWcs >	readString (std::string &str)
	Deserialize a SkyWcs from a string, using the same format as readStream.
static std::shared_ptr< SkyWcs >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object.
static std::shared_ptr< SkyWcs >	readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
	Read an object from a regular FITS file.
static std::shared_ptr< SkyWcs >	readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
	Read an object from a FITS file in memory.
static std::shared_ptr< SkyWcs >	dynamicCast (std::shared_ptr< Persistable > const &ptr)
	Dynamically cast a shared_ptr.

Protected Types
using	OutputArchiveHandle = io::OutputArchiveHandle

Protected Member Functions
std::string	getPersistenceName () const override
	Return the unique name used to persist this object and look up its factory.
std::string	getPythonModule () const override
	Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.
void	write (OutputArchiveHandle &handle) const override
	Write the object to one or more catalogs.

Static Protected Member Functions
template<class T >
static bool	singleClassEquals (T const &lhs, Storable const &rhs)
	Test if a Storable is of a particular class and equal to another object.

Related Symbols
(Note that these are not member symbols.)
std::ostream &	operator<< (std::ostream &os, Storable const &storable)
	Output operator for Storable.

Detailed Description

A 2-dimensional celestial WCS that transform pixels to ICRS RA/Dec, using the LSST standard for pixels.

SkyWcs is an immutable object that can not only represent any standard FITS WCS, but can also contain arbitrary Transforms, e.g. to model optical distortion or pixel imperfections.

In order to make a SkyWcs that models optical distortion, say, it is usually simplest to start with a standard FITS WCS (such as a TAN WCS) as an approximation, then insert a transform that models optical distortion by calling makeModifiedWcs. However, it is also possible to build a SkyWcs entirely from transforms, if you prefer, by building an ast::FrameDict and constructing the SkyWcs from that.

Frames of reference

SkyWcs internally keeps track of the following frames of reference:

• cameraGeom::ACTUAL_PIXELS (optional): "actual" pixel position using the LSST standard. This has the same meaning as the cameraGeom::ACTUAL_PIXELS frame: actual pixels include effects such as "tree ring" distortions and electrical effects at the edge of CCDs. This frame should only be provided if there is a reasonable model for these imperfections.
• cameraGeom::PIXELS: nominal pixel position, using the LSST standard. This has the same meaning as the cameraGeom::PIXELS frame: nominal pixels may be rectangular, but are uniform in size and spacing.
• IWC: intermediate world coordinates (the FITS WCS concept).
• SKY: position on the sky as ICRS, with standard RA, Dec axis order.

Pixel position standards

The LSST standard for pixel position is: 0,0 is the center of the lower left image pixel. The FITS standard for pixel position is: 1,1 is the center of the lower left image pixel.

LSST and FITS also use a different origin for subimages:

• LSST pixel position is in the frame of reference of the parent image
• FITS pixel position is in the frame of reference of the subimage However, SkyWcs does not keep track of this difference. Code that persists and unpersists SkyWcs using FITS-WCS header cards must handle the offset, e.g. by calling copyAtShiftedPixelOrigin

Internal details: the contained ast::FrameDict

SkyWcs contains an ast::FrameDict which transforms from pixels to sky (in radians) in the forward direction.

This FrameDict contains the named frames described in frames of reference, e.g. "SKY", "IWC", cameraGeom::PIXELS and possibly cameraGeom::ACTUAL_PIXELS. "SKY" is the current frame. If cameraGeom::ACTUAL_PIXELS is present then it is the base frame, otherwise cameraGeom::PIXELS is the base frame.

The "SKY" frame is of type ast::SkyFrame and has the following attributes:

• SkyRef is set to the sky origin of the WCS (ICRS RA, Dec) in radians.
• SkyRefIs is set to "Ignored" so that SkyRef is not used in transformations.

The other frames are of type ast::Frame and have 2 axes.

Definition at line 117 of file SkyWcs.h.

Member Typedef Documentation

OutputArchiveHandle

using lsst::afw::table::io::Persistable::OutputArchiveHandle = io::OutputArchiveHandle

protectedinherited

Definition at line 108 of file Persistable.h.

Constructor & Destructor Documentation

SkyWcs() [1/4]

lsst::afw::geom::SkyWcs::SkyWcs ( SkyWcs const & )

default

SkyWcs() [2/4]

lsst::afw::geom::SkyWcs::SkyWcs ( SkyWcs && )

default

~SkyWcs()

lsst::afw::geom::SkyWcs::~SkyWcs ( )

overridedefault

SkyWcs() [3/4]

lsst::afw::geom::SkyWcs::SkyWcs ( daf::base::PropertySet & metadata, bool strip = false )

explicit

Construct a SkyWcs from FITS keywords.

Parameters

[in]	metadata	FITS header metadata
[in]	strip	If true: strip items from metadata used to create the WCS, such as RADESYS, EQUINOX, CTYPE12, CRPIX12, CRVAL12, etc. Always keep keywords that might be wanted for other purpposes, including NAXIS12 and date-related keywords such as "DATE-OBS" and "TIMESYS" (but not "EQUINOX").

Exceptions

lsst::pex::exceptions::TypeError

if the metadata does not describe a celestial WCS.

Definition at line 151 of file SkyWcs.cc.

        : SkyWcs(detail::readLsstSkyWcs(metadata, strip)) {}

SkyWcs() [4/4]

lsst::afw::geom::SkyWcs::SkyWcs ( ast::FrameDict const & frameDict )

explicit

Construct a SkyWcs from an ast::FrameDict.

This is the most general constructor; it can be used to define any celestial WCS. Note that in many cases the result will not be exactly representable as a FITS WCS.

Parameters

[in]

frameDict

An ast::FrameDict that describes the transformation from pixels to sky. It must meet the requirements outlined in the contained ast::FrameDict.

Exceptions

lsst::pex::exceptions::TypeError

if frameDict is missing any of the required frames of reference.

Definition at line 154 of file SkyWcs.cc.

: SkyWcs(_checkFrameDict(frameDict)) {}

Member Function Documentation

cloneStorable()

std::shared_ptr< typehandling::Storable > lsst::afw::geom::SkyWcs::cloneStorable ( ) const

overridevirtual

Create a new SkyWcs that is a copy of this one.

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 348 of file SkyWcs.cc.

                                                                {
    return std::make_unique<SkyWcs>(*this);
}

copyAtShiftedPixelOrigin()

std::shared_ptr< SkyWcs > lsst::afw::geom::SkyWcs::copyAtShiftedPixelOrigin

(

lsst::geom::Extent2D const &

shift

)

const

Return a copy of this SkyWcs with the pixel origin shifted by the specified amount.

new pixel origin = the old pixel origin + shift

Parameters

[in]

shift

The amount by which to shift the pixel origin (pixels)

Definition at line 208 of file SkyWcs.cc.

                                                                                          {
    auto newToOldPixel = TransformPoint2ToPoint2(ast::ShiftMap({-shift[0], -shift[1]}));
    return makeModifiedWcs(newToOldPixel, *this, true);
}

dynamicCast()

template std::shared_ptr< meas::extensions::psfex::PsfexPsf > lsst::afw::table::io::PersistableFacade< SkyWcs >::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 218 of file Persistable.cc.

equals()

bool lsst::afw::geom::SkyWcs::equals ( typehandling::Storable const & other ) const

overridevirtualnoexcept

Compare this object to another Storable.

Returns

*this == other if other is a SkyWcs; otherwise false.

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 373 of file SkyWcs.cc.

                                                                    {
    return singleClassEquals(*this, other);
}

getCdMatrix() [1/2]

Eigen::Matrix2d lsst::afw::geom::SkyWcs::getCdMatrix

(

)

const

Get the 2x2 CD matrix at the pixel origin.

The elements are in degrees

Definition at line 199 of file SkyWcs.cc.

{ return getCdMatrix(getPixelOrigin()); }

getCdMatrix() [2/2]

Eigen::Matrix2d lsst::afw::geom::SkyWcs::getCdMatrix

(

lsst::geom::Point2D const &

pixel

)

const

Get the 2x2 CD matrix at the specified pixel position.

The elements are in degrees

Definition at line 193 of file SkyWcs.cc.

                                                                    {
    auto const pixelToIwc = getFrameDict()->getMapping(ast::FrameSet::BASE, "IWC");
    auto const pixelToIwcTransform = TransformPoint2ToPoint2(*pixelToIwc);
    return pixelToIwcTransform.getJacobian(pixel);
}

getFitsMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::geom::SkyWcs::getFitsMetadata

(

bool

precise = false

)

const

Return the WCS as FITS WCS metadata.

Parameters

[in]

precise

Fail if the WCS cannot be accurately represented as FITS metadata? If False then return an approximation. For now that approximation is pure TAN but as of DM-13170 it will be a fit TAN-SIP. The required precision is set by constant TIGHT_FITS_TOL in SkyWcs.cc

FITS representations of WCS are described in "Representations of World Coordinates in FITS" by Greisen and Calabretta and several related papers.

The required precision is hard-coded as constant TIGHT_FITS_TOL in SkyWcs.cc

Exceptions

lsst::pex::exceptions::RuntimeError

if precise is true and AST cannot represent this WCS as a FITS WCS to sufficient precision.

Definition at line 213 of file SkyWcs.cc.

                                                                             {
    // Make a FrameSet that maps from GRID to SKY; GRID = the base frame (PIXELS or ACTUAL_PIXELS) + 1
    auto const gridToPixel = ast::ShiftMap({-1.0, -1.0});
    auto thisDict = getFrameDict();
    auto const pixelToIwc = thisDict->getMapping(ast::FrameSet::BASE, "IWC");
    auto const iwcToSky = thisDict->getMapping("IWC", "SKY");
    auto const gridToSky = gridToPixel.then(*pixelToIwc).then(*iwcToSky);
    ast::FrameSet frameSet(ast::Frame(2, "Domain=GRID"), gridToSky, *thisDict->getFrame("SKY", false));
 
    // Write frameSet to a FitsChan and extract the metadata
    std::ostringstream os;
    os << "Encoding=FITS-WCS, CDMatrix=1, FitsAxisOrder=<copy>, FitsTol=" << TIGHT_FITS_TOL;
    ast::StringStream strStream;
    ast::FitsChan fitsChan(strStream, os.str());
    int const nObjectsWritten = fitsChan.write(frameSet);
    std::shared_ptr<daf::base::PropertyList> header;
    if (nObjectsWritten == 0) {
        if (precise) {
            throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError,
                              "Could not represent this SkyWcs using FITS-WCS metadata");
        } else {
            // An exact representation could not be written, so try to write a local TAN approximation;
            // set precise true to avoid an infinite loop, should something go wrong
            auto tanWcs = getTanWcs(getPixelOrigin());
            header = tanWcs->getFitsMetadata(true);
        }
    } else {
        header = detail::getPropertyListFromFitsChan(fitsChan);
    }
 
    // Remove DATE-OBS, MJD-OBS: AST writes these if the EQUINOX is set, but we set them via other mechanisms.
    header->remove("DATE-OBS");
    header->remove("MJD-OBS");
 
    // If CD matrix is present, explicitly set any missing entries to zero, as a convenience to the user
    bool const hasCd11 = header->exists("CD1_1");
    bool const hasCd12 = header->exists("CD1_2");
    bool const hasCd21 = header->exists("CD2_1");
    bool const hasCd22 = header->exists("CD2_2");
    if (hasCd11 || hasCd12 || hasCd21 || hasCd22) {
        if (!hasCd11) header->set("CD1_1", 0.0, "Transformation matrix element");
        if (!hasCd12) header->set("CD1_2", 0.0, "Transformation matrix element");
        if (!hasCd21) header->set("CD2_1", 0.0, "Transformation matrix element");
        if (!hasCd22) header->set("CD2_2", 0.0, "Transformation matrix element");
    }
 
    return header;
}

getFrameDict()

std::shared_ptr< const ast::FrameDict > lsst::afw::geom::SkyWcs::getFrameDict

(

)

const

Get the contained FrameDict.

The base frame will be cameraGeom::PIXELS or cameraGeom::ACTUAL_PIXELS and the current frame will be SKY, so the forward transform goes from pixels (using the LSST zero convention) to sky ICRS RA, Dec (in radians). For more details see the contained ast::FrameDict

Definition at line 262 of file SkyWcs.cc.

{ return _frameDict; }

getPersistenceName()

std::string lsst::afw::geom::SkyWcs::getPersistenceName ( ) const

overrideprotectedvirtual

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 377 of file SkyWcs.cc.

{ return getSkyWcsPersistenceName(); }

getPixelOrigin()

lsst::geom::Point2D lsst::afw::geom::SkyWcs::getPixelOrigin ( ) const

inline

Get the pixel origin, in pixels, using the LSST convention.

This is CRPIX1 - 1, CRPIX2 -1 in FITS terminology

Definition at line 215 of file SkyWcs.h.

{ return _pixelOrigin; };

getPixelScale() [1/2]

lsst::geom::Angle lsst::afw::geom::SkyWcs::getPixelScale ( ) const

inline

Get the pixel scale at the pixel origin.

The scale is the square root of the area of the specified pixel on the sky.

The value is cached, so this is a cheap call.

Definition at line 208 of file SkyWcs.h.

{ return _pixelScaleAtOrigin; };

getPixelScale() [2/2]

lsst::geom::Angle lsst::afw::geom::SkyWcs::getPixelScale

(

lsst::geom::Point2D const &

pixel

)

const

Get the pixel scale at the specified pixel position.

The scale is the square root of the area of the specified pixel on the sky.

Warning

Unlike getPixelScale() the value is not cached, even if pixel = pixel origin.

Definition at line 158 of file SkyWcs.cc.

                                                                      {
    // Compute pixVec containing the pixel position and two nearby points
    // (use a vector so all three points can be converted to sky in a single call)
    double const side = 1.0;
    std::vector<lsst::geom::Point2D> pixVec = {
            pixel,
            pixel + lsst::geom::Extent2D(side, 0),
            pixel + lsst::geom::Extent2D(0, side),
    };
 
    auto skyVec = pixelToSky(pixVec);
 
    // Work in 3-space to avoid RA wrapping and pole issues
    auto skyLL = skyVec[0].getVector();
    auto skyDx = skyVec[1].getVector() - skyLL;
    auto skyDy = skyVec[2].getVector() - skyLL;
 
    // Compute pixel scale in radians = sqrt(pixel area in radians^2)
    // pixel area in radians^2 = area of parallelogram with sides skyDx, skyDy = |skyDx cross skyDy|
    // Use squared norm to avoid two square roots
    double skyAreaSq = skyDx.cross(skyDy).getSquaredNorm();
    return (std::pow(skyAreaSq, 0.25) / side) * lsst::geom::radians;
}

getPythonModule()

std::string lsst::afw::geom::SkyWcs::getPythonModule ( ) const

overrideprotectedvirtual

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 379 of file SkyWcs.cc.

{ return "lsst.afw.geom"; }

getShortClassName()

std::string lsst::afw::geom::SkyWcs::getShortClassName ( )

static

Definition at line 294 of file SkyWcs.cc.

{ return "SkyWcs"; };

getSkyOrigin()

lsst::geom::SpherePoint lsst::afw::geom::SkyWcs::getSkyOrigin

(

)

const

Get the sky origin, the celestial fiducial point.

This is CRVAL1, CRVAL2 in FITS terminology

Definition at line 182 of file SkyWcs.cc.

                                               {
    // CRVAL is stored as the SkyRef property of the sky frame (the current frame of the SkyWcs)
    auto skyFrame = std::dynamic_pointer_cast<ast::SkyFrame>(
            getFrameDict()->getFrame(ast::FrameDict::CURRENT, false));  // false: do not copy
    if (!skyFrame) {
        throw LSST_EXCEPT(pex::exceptions::LogicError, "Current frame is not a SkyFrame");
    }
    auto const crvalRad = skyFrame->getSkyRef();
    return lsst::geom::SpherePoint(crvalRad[0] * lsst::geom::radians, crvalRad[1] * lsst::geom::radians);
}

getTanWcs()

std::shared_ptr< SkyWcs > lsst::afw::geom::SkyWcs::getTanWcs

(

lsst::geom::Point2D const &

pixel

)

const

Get a local TAN WCS approximation to this WCS at the specified pixel position.

Definition at line 201 of file SkyWcs.cc.

                                                                          {
    auto const crval = pixelToSky(pixel);
    auto const cdMatrix = getCdMatrix(pixel);
    auto metadata = makeSimpleWcsMetadata(pixel, crval, cdMatrix);
    return std::make_shared<SkyWcs>(*metadata);
}

getTransform()

std::shared_ptr< const TransformPoint2ToSpherePoint > lsst::afw::geom::SkyWcs::getTransform ( ) const

inline

Get a TransformPoint2ToSpherePoint that transforms pixels to sky in the forward direction and sky to pixels in the inverse direction.

Definition at line 257 of file SkyWcs.h.

{ return _transform; };

hasFitsApproximation()

bool lsst::afw::geom::SkyWcs::hasFitsApproximation ( ) const

inline

Does this SkyWcs have an approximate SkyWcs that can be represented as standard FITS WCS?

This feature is not yet implemented, so hasFitsApproximation is always false.

Definition at line 364 of file SkyWcs.h.

{ return false; }

hash_value()

std::size_t lsst::afw::typehandling::Storable::hash_value ( ) const

virtualinherited

Return a hash of this object (optional operation).

Exceptions

UnsupportedOperationException

Thrown if this object is not hashable.

Note

C++ subclass authors are responsible for any associated specializations of std::hash.

When called on Python classes, this method delegates to __hash__ if it exists.

Reimplemented in lsst::afw::geom::polygon::Polygon, lsst::afw::image::FilterLabel, lsst::afw::image::VisitInfo, and lsst::afw::typehandling::StorableHelper< Base >.

Definition at line 44 of file Storable.cc.

                                     {
    throw LSST_EXCEPT(UnsupportedOperationException, "Hashes are not supported.");
}

isFits()

bool lsst::afw::geom::SkyWcs::isFits

(

)

const

Return true getFitsMetadata(true) will succeed, false if not.

In other words, true indicates that the WCS can be accurately represented using FITS WCS metadata.

Definition at line 264 of file SkyWcs.cc.

                          {
    try {
        getFitsMetadata(true);
    } catch (const lsst::pex::exceptions::RuntimeError&) {
        return false;
    } catch (const std::runtime_error&) {
        return false;
    }
    return true;
}

isFlipped()

bool lsst::afw::geom::SkyWcs::isFlipped

(

)

const

Does the WCS follow the convention of North=Up, East=Left?

Returns

False/true if E is along -X/+X when the N/E axes are rotated so that N is along image +Y.

Exceptions

lsst::pex::exceptions::RuntimeError

if the parity cannot be determined because the CD matrix is singular.

Definition at line 296 of file SkyWcs.cc.

                             {
    double det = getCdMatrix().determinant();
    if (det == 0) {
        throw(LSST_EXCEPT(pex::exceptions::RuntimeError, "CD matrix is singular"));
    }
    return (det > 0);
}

isPersistable()

bool lsst::afw::geom::SkyWcs::isPersistable ( ) const

inlineoverridevirtualnoexcept

Return true if this particular object can be persisted using afw::table::io.

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

Definition at line 268 of file SkyWcs.h.

{ return true; }

linearizePixelToSky() [1/2]

lsst::geom::AffineTransform lsst::afw::geom::SkyWcs::linearizePixelToSky	(	lsst::geom::Point2D const &	pixel,
		lsst::geom::AngleUnit const &	skyUnit ) const

Return the local linear approximation to pixelToSky at a point given in pixel coordinates.

The local linear approximation is defined such the following is true (ignoring floating-point errors):

wcs.linearizePixelToSky(pixel, skyUnit)(pixel) == wcs.pixelToSky(pixel).getPosition(skyUnit)

(lsst::geom::AffineTransform::operator() applies the transform in the forward direction)

Parameters

[in]	pixel	Position in pixel coordinates where transform is desired.
[in]	skyUnit	Units to use for sky coordinates; units of matrix elements will be skyUnits/pixel.

Definition at line 279 of file SkyWcs.cc.

                                                                                                {
    return _linearizePixelToSky(pix, pixelToSky(pix), skyUnit);
}

linearizePixelToSky() [2/2]

lsst::geom::AffineTransform lsst::afw::geom::SkyWcs::linearizePixelToSky	(	lsst::geom::SpherePoint const &	coord,
		lsst::geom::AngleUnit const &	skyUnit ) const

Return the local linear approximation to pixelToSky at a point given in sky coordinates.

The local linear approximation is defined such the following is true (ignoring floating-point errors):

wcs.linearizePixelToSky(sky, skyUnit)(wcs.skyToPixel(sky)) == sky.getPosition(skyUnit);

(lsst::geom::AffineTransform::operator() applies the transform in the forward direction)

Parameters

[in]	coord	Position in sky coordinates where transform is desired.
[in]	skyUnit	Units to use for sky coordinates; units of matrix elements will be skyUnits/pixel.

Definition at line 275 of file SkyWcs.cc.

                                                                                                {
    return _linearizePixelToSky(skyToPixel(coord), coord, skyUnit);
}

linearizeSkyToPixel() [1/2]

lsst::geom::AffineTransform lsst::afw::geom::SkyWcs::linearizeSkyToPixel	(	lsst::geom::Point2D const &	pixel,
		lsst::geom::AngleUnit const &	skyUnit ) const

Return the local linear approximation to skyToPixel at a point given in pixel coordinates.

The local linear approximation is defined such the following is true (ignoring floating-point errors):

wcs.linearizeSkyToPixel(pixel, skyUnit)(wcs.pixelToSky(pixel).getPosition(skyUnit)) == pixel

(lsst::geom::AffineTransform::operator() applies the transform in the forward direction)

Parameters

[in]	pixel	Position in pixel coordinates where transform is desired.
[in]	skyUnit	Units to use for sky coordinates; units of matrix elements will be pixels/skyUnit.

Definition at line 289 of file SkyWcs.cc.

                                                                                                {
    return _linearizeSkyToPixel(pix, pixelToSky(pix), skyUnit);
}

linearizeSkyToPixel() [2/2]

lsst::geom::AffineTransform lsst::afw::geom::SkyWcs::linearizeSkyToPixel	(	lsst::geom::SpherePoint const &	coord,
		lsst::geom::AngleUnit const &	skyUnit ) const

Return the local linear approximation to skyToPixel at a point given in sky coordinates.

The local linear approximation is defined such the following is true (ignoring floating-point errors):

wcs.linearizeSkyToPixel(sky, skyUnit)(sky.getPosition(skyUnit)) == wcs.skyToPixel(sky)

(lsst::geom::AffineTransform::operator() applies the transform in the forward direction)

Parameters

[in]	coord	Position in sky coordinates where transform is desired.
[in]	skyUnit	Units to use for sky coordinates; units of matrix elements will be pixels/skyUnit.

Definition at line 284 of file SkyWcs.cc.

                                                                                                {
    return _linearizeSkyToPixel(skyToPixel(coord), coord, skyUnit);
}

operator!=()

bool lsst::afw::geom::SkyWcs::operator!= ( SkyWcs const & other ) const

inline

Definition at line 136 of file SkyWcs.h.

{ return !(*this == other); }

operator=() [1/2]

SkyWcs & lsst::afw::geom::SkyWcs::operator= ( SkyWcs && )

delete

operator=() [2/2]

SkyWcs & lsst::afw::geom::SkyWcs::operator= ( SkyWcs const & )

delete

operator==()

bool lsst::afw::geom::SkyWcs::operator==

(

SkyWcs const &

other

)

const

Equality is based on the string representations being equal.

Two SkyWcs constructed the same way will be equal, and a SkyWcs that has been saved and restored will be equal to the original. However, it is possible to construct two SkyWcs that behave identically as far as transforming points go, but will compare as unequal due to subtle internal differences, such as a contained ast::Mapping that has a different ID in one SkyWcs than another.

Thus equality is primarily useful for testing persistence.

Definition at line 156 of file SkyWcs.cc.

{ return writeString() == other.writeString(); }

pixelToSky() [1/3]

lsst::geom::SpherePoint lsst::afw::geom::SkyWcs::pixelToSky ( double x, double y ) const

inline

Definition at line 337 of file SkyWcs.h.

                                                             {
        return pixelToSky(lsst::geom::Point2D(x, y));
    }

pixelToSky() [2/3]

lsst::geom::SpherePoint lsst::afw::geom::SkyWcs::pixelToSky ( lsst::geom::Point2D const & pixel ) const

inline

Compute sky position(s) from pixel position(s)

Definition at line 334 of file SkyWcs.h.

                                                                       {
        return _transform->applyForward(pixel);
    }

pixelToSky() [3/3]

std::vector< lsst::geom::SpherePoint > lsst::afw::geom::SkyWcs::pixelToSky ( std::vector< lsst::geom::Point2D > const & pixels ) const

inline

Definition at line 340 of file SkyWcs.h.

                                                                                              {
        return _transform->applyForward(pixels);
    }

readFits() [1/3]

static std::shared_ptr< SkyWcs > lsst::afw::table::io::PersistableFacade< SkyWcs >::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.

readFits() [2/3]

static std::shared_ptr< SkyWcs > lsst::afw::table::io::PersistableFacade< SkyWcs >::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.

readFits() [3/3]

static std::shared_ptr< SkyWcs > lsst::afw::table::io::PersistableFacade< SkyWcs >::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.

readStream()

std::shared_ptr< SkyWcs > lsst::afw::geom::SkyWcs::readStream ( std::istream & is )

static

Deserialize a SkyWcs from an input stream.

Parameters

[in]

is

input stream from which to deserialize this SkyWcs

Definition at line 304 of file SkyWcs.cc.

                                                       {
    int version;
    is >> version;
    if (version != 1) {
        throw LSST_EXCEPT(pex::exceptions::TypeError, "Unsupported version " + std::to_string(version));
    }
    std::string shortClassName;
    is >> shortClassName;
    if (shortClassName != SkyWcs::getShortClassName()) {
        std::ostringstream os;
        os << "Class name in stream " << shortClassName << " != " << SkyWcs::getShortClassName();
        throw LSST_EXCEPT(pex::exceptions::TypeError, os.str());
    }
    bool hasFitsApproximation;
    is >> hasFitsApproximation;
    auto astStream = ast::Stream(&is, nullptr);
    auto astObjectPtr = ast::Channel(astStream).read();
    auto frameSet = std::dynamic_pointer_cast<ast::FrameSet>(astObjectPtr);
    if (!frameSet) {
        std::ostringstream os;
        os << "The AST serialization was read as a " << astObjectPtr->getClassName()
           << " instead of a FrameSet";
        throw LSST_EXCEPT(pex::exceptions::TypeError, os.str());
    }
    ast::FrameDict frameDict(*frameSet);
    return std::make_shared<SkyWcs>(frameDict);
}

readString()

std::shared_ptr< SkyWcs > lsst::afw::geom::SkyWcs::readString ( std::string & str )

static

Deserialize a SkyWcs from a string, using the same format as readStream.

Definition at line 332 of file SkyWcs.cc.

                                                       {
    std::istringstream is(str);
    return SkyWcs::readStream(is);
}

singleClassEquals()

template<class T >

static bool lsst::afw::typehandling::Storable::singleClassEquals ( T const & lhs, Storable const & rhs )

inlinestaticprotectedinherited

Test if a Storable is of a particular class and equal to another object.

This method template simplifies implementations of equals that delegate to operator== without supporting cross-class comparisons.

Template Parameters

T	The class expected of the two objects to be compared.

Parameters

lhs,rhs

The objects to compare. Note that rhs need not be a T, while lhs must be.

Returns

true if rhs is a T and lhs == rhs; false otherwise.

Exception Safety

Provides the same level of exception safety as operator==. Most implementations of operator== do not throw.

Note

This method template calls operator== with both arguments of compile-time type T const&. Its use is not recommended if there would be any ambiguity as to which operator== gets picked by overload resolution.

This method template is typically called from equals as:

bool MyType::equals(Storable const& other) const noexcept {
    return singleClassEquals(*this, other);
}

Definition at line 151 of file Storable.h.

                                                                     {
        auto typedRhs = dynamic_cast<T const*>(&rhs);
        if (typedRhs != nullptr) {
            return lhs == *typedRhs;
        } else {
            return false;
        }
    }

skyToPixel() [1/2]

lsst::geom::Point2D lsst::afw::geom::SkyWcs::skyToPixel ( lsst::geom::SpherePoint const & sky ) const

inline

Compute pixel position(s) from sky position(s)

Definition at line 349 of file SkyWcs.h.

                                                                     {
        return _transform->applyInverse(sky);
    }

skyToPixel() [2/2]

std::vector< lsst::geom::Point2D > lsst::afw::geom::SkyWcs::skyToPixel ( std::vector< lsst::geom::SpherePoint > const & sky ) const

inline

Definition at line 352 of file SkyWcs.h.

                                                                                           {
        return _transform->applyInverse(sky);
    }

toString()

std::string lsst::afw::geom::SkyWcs::toString ( ) const

overridevirtual

Create a string representation of this object.

An example of the output might look like this (note the newlines):

FITS standard SkyWcs:
Sky Origin: (0.000000, +45.000000)
Pixel Origin: (100, 100)
Pixel Scale: 1 arcsec/pixel

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 352 of file SkyWcs.cc.

                                 {
    std::ostringstream os;
    if (isFits()) {
        os << "FITS standard SkyWcs:";
    } else {
        os << "Non-standard SkyWcs (Frames: ";
        // Print the frames in index order (frames are numbered from 1).
        std::string delimiter = "";
        for (size_t i = 1; i <= getFrameDict()->getAllDomains().size(); ++i) {
            os << delimiter << getFrameDict()->getFrame(i)->getDomain();
            delimiter = ", ";
        }
        os << "): ";
    }
    std::string delimiter = "\n";
    os << delimiter << "Sky Origin: " << getSkyOrigin();
    os << delimiter << "Pixel Origin: " << getPixelOrigin();
    os << delimiter << "Pixel Scale: " << getPixelScale().asArcseconds() << " arcsec/pixel";
    return os.str();
}

write()

void lsst::afw::geom::SkyWcs::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 381 of file SkyWcs.cc.

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

writeFits() [1/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);
}

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 ( 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);
}

writeStream()

void lsst::afw::geom::SkyWcs::writeStream

(

std::ostream &

os

)

const

Serialize this SkyWcs to an output stream.

Version 1 format is as follows:

• The version number (an integer)
• A space
• getShortClassName()
• A space
• hasFitsApproximation()
• A space
• The contained ast::FrameDict written using FrameDict.show(os, false)

If and when fits approximation is supported, the approximate WCS will be written as a second FrameDict immediately following the first.

Parameters

[out]

os

output stream to which to serialize this SkyWcs

Definition at line 337 of file SkyWcs.cc.

                                             {
    os << SERIALIZATION_VERSION << " " << SkyWcs::getShortClassName() << " " << hasFitsApproximation() << " ";
    getFrameDict()->show(os, false);  // false = do not write comments
}

writeString()

std::string lsst::afw::geom::SkyWcs::writeString

(

)

const

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

Definition at line 342 of file SkyWcs.cc.

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

Friends And Related Symbol Documentation

operator<<()

std::ostream & operator<< ( std::ostream & os, Storable const & storable )

related

Output operator for Storable.

Parameters

os	the desired output stream
storable	the object to print

Returns

a reference to os

Exceptions

UnsupportedOperationException

Thrown if storable does not have an implementation of Storable::toString.

Definition at line 174 of file Storable.h.

                                                                        {
    return os << storable.toString();
}

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/gef2f8181fd+0a71e47438/include/lsst/afw/geom/SkyWcs.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/gef2f8181fd+0a71e47438/src/geom/SkyWcs.cc