lsst.afw.coord::Coord Class Reference

#include <Coord.h>

Inheritance diagram for lsst.afw.coord::Coord:

Public Types
typedef boost::shared_ptr< Coord >	Ptr
typedef boost::shared_ptr < Coord const >	ConstPtr

Public Member Functions
	Coord (lsst::afw::geom::Point2D const &p2d, lsst::afw::geom::AngleUnit unit=lsst::afw::geom::degrees, double const epoch=2000.0)
	Constructor for the Coord base class. More...
	Coord (lsst::afw::geom::Point3D const &p3d, double const epoch=2000.0, bool normalize=true, lsst::afw::geom::Angle const defaultLongitude=lsst::afw::geom::Angle(0.))
	Constructor for the Coord base class. More...
	Coord (lsst::afw::geom::Angle const ra, lsst::afw::geom::Angle const dec, double const epoch=2000.0)
	Constructor for the Coord base class. More...
	Coord (std::string const ra, std::string const dec, double const epoch=2000.0)
	Constructor for the Coord base class. More...
	Coord ()
	Default constructor for the Coord base class. More...
virtual	~Coord ()
virtual Coord::Ptr	clone () const
virtual void	reset (lsst::afw::geom::Angle const longitude, lsst::afw::geom::Angle const latitude)
virtual void	reset (lsst::afw::geom::Angle const longitude, lsst::afw::geom::Angle const latitude, double const epoch)
	Reset our coordinates wholesale. More...
double	getEpoch () const
lsst::afw::geom::Point2D	getPosition (lsst::afw::geom::AngleUnit unit=lsst::afw::geom::degrees) const
	Return our contents in a Point2D object. More...
lsst::afw::geom::Point3D	getVector () const
	Return our contents in a position vector. More...
virtual std::pair< std::string, std::string >	getCoordNames () const
virtual std::string	getClassName () const
lsst::afw::geom::Angle	operator[] (int const index) const
	Provide access to our contents via an index. More...
bool	operator== (Coord const &rhs) const
	Equality operator, compares each element directly. More...
lsst::afw::geom::Angle	getLongitude () const
	The main access method for the longitudinal coordinate. More...
lsst::afw::geom::Angle	getLatitude () const
	The main access method for the latitudinal coordinate. More...
std::string	getLongitudeStr (lsst::afw::geom::AngleUnit unit) const
	Allow quick access to the longitudinal coordinate as a string. More...
std::string	getLatitudeStr () const
	Allow quick access to the longitude coordinate as a string. More...
Coord	transform (Coord const &poleFrom, Coord const &poleTo) const
	Tranform our current coords to another spherical polar system. More...
lsst::afw::geom::Angle	angularSeparation (Coord const &c) const
	compute the angular separation between two Coords More...
std::pair < lsst::afw::geom::Angle, lsst::afw::geom::Angle >	getOffsetFrom (Coord const &c) const
	Compute the offset from a coordinate. More...
std::pair < lsst::afw::geom::Angle, lsst::afw::geom::Angle >	getTangentPlaneOffset (Coord const &c) const
	Get the offset on the tangent plane. More...
void	rotate (Coord const &axis, lsst::afw::geom::Angle const theta)
	Rotate our current coords about a pole. More...
lsst::afw::geom::Angle	offset (lsst::afw::geom::Angle const phi, lsst::afw::geom::Angle const arcLen)
	offset our current coords along a great circle defined by an angle wrt a declination parallel More...
Coord::Ptr	convert (CoordSystem system) const
	Convert to a specified Coord type. More...
virtual Fk5Coord	toFk5 (double const epoch) const
	Convert ourself to Fk5: RA, Dec (precess to new epoch) More...
virtual Fk5Coord	toFk5 () const
	Convert ourself to Fk5: RA, Dec (use current epoch) More...
virtual IcrsCoord	toIcrs () const
	Convert ourself to ICRS: RA, Dec (basically J2000) More...
virtual GalacticCoord	toGalactic () const
	Convert ourself to Galactic: l, b. More...
virtual EclipticCoord	toEcliptic (double const epoch) const
	Convert ourself to Ecliptic: lambda, beta (precess to new epoch) More...
virtual EclipticCoord	toEcliptic () const
	Convert ourself to Ecliptic: lambda, beta (use existing epoch) More...
virtual TopocentricCoord	toTopocentric (Observatory const &obs, lsst::daf::base::DateTime const &obsDate) const
	Convert ourself to Altitude/Azimuth: alt, az. More...

Private Member Functions
void	_verifyValues () const
	Make sure the values we've got are in the range 0 <= x < 2PI. More...

Private Attributes
lsst::afw::geom::Angle	_longitude
lsst::afw::geom::Angle	_latitude
double	_epoch

Detailed Description

This is the base class for spherical coordinates.

Definition at line 69 of file Coord.h.

Member Typedef Documentation

typedef boost::shared_ptr<Coord const> lsst.afw.coord::Coord::ConstPtr

Definition at line 73 of file Coord.h.

typedef boost::shared_ptr<Coord> lsst.afw.coord::Coord::Ptr

Definition at line 72 of file Coord.h.

Constructor & Destructor Documentation

lsst.afw.coord::Coord::Coord	(	lsst::afw::geom::Point2D const &	p2d,
		lsst::afw::geom::AngleUnit	unit = lsst::afw::geom::degrees,
		double const	epoch = 2000.0
	)

Constructor for the Coord base class.

Parameters

p2d	Point2D
unit	Rads, Degs, or Hrs
epoch	epoch of coordinate

Definition at line 373 of file Coord.cc.

                        :
    _longitude(NaN), _latitude(NaN), _epoch(epoch) {
    _longitude = afwGeom::Angle(p2d.getX(), unit);
    _longitude.wrap();
    _latitude  = afwGeom::Angle(p2d.getY(), unit);
    _verifyValues();
}

lsst.afw.coord::Coord::Coord	(	lsst::afw::geom::Point3D const &	p3d,
		double const	epoch = 2000.0,
		bool	normalize = true,
		lsst::afw::geom::Angle const	defaultLongitude = lsst::afw::geom::Angle(0.)
	)

Constructor for the Coord base class.

Parameters

p3d	Point3D
epoch	epoch of coordinate
normalize	normalize the p3d provided
defaultLongitude	longitude to use if x=y=0

Definition at line 388 of file Coord.cc.

                        :
    _longitude(0. * afwGeom::radians),
    _latitude(0. * afwGeom::radians),
    _epoch(epoch) {

    std::pair<afwGeom::Angle, afwGeom::Angle> lonLat = pointToLonLat(p3d, defaultLongitude, normalize);
    _longitude = lonLat.first;
    _latitude  = lonLat.second;
    _epoch = epoch;
}

lsst.afw.coord::Coord::Coord	(	lsst::afw::geom::Angle const	ra,
		lsst::afw::geom::Angle const	dec,
		double const	epoch = 2000.0
	)

Constructor for the Coord base class.

Parameters

ra	Right ascension, decimal degrees
dec	Declination, decimal degrees
epoch	epoch of coordinate

Definition at line 408 of file Coord.cc.

                        :
    _longitude(ra), _latitude(dec), _epoch(epoch) {
    _longitude.wrap();
    _verifyValues();
}

lsst.afw.coord::Coord::Coord	(	std::string const	ra,
		std::string const	dec,
		double const	epoch = 2000.0
	)

Constructor for the Coord base class.

Parameters

ra	Right ascension, hh:mm:ss.s format
dec	Declination, dd:mm:ss.s format
epoch	epoch of coordinate

Definition at line 422 of file Coord.cc.

                        :
    _longitude(hmsStringToAngle(ra)),
    _latitude(dmsStringToAngle(dec)),
    _epoch(epoch) {
    _longitude.wrap();
    _verifyValues();
}

lsst.afw.coord::Coord::Coord

(

)

Default constructor for the Coord base class.

Set all values to NaN Don't call _veriftyValues() method ... it'll fail.

Definition at line 441 of file Coord.cc.

: _longitude(afwGeom::Angle(NaN)), _latitude(afwGeom::Angle(NaN)), _epoch(NaN) {}

virtual lsst.afw.coord::Coord::~Coord ( )

inlinevirtual

Definition at line 82 of file Coord.h.

{}

Member Function Documentation

void lsst.afw.coord::Coord::_verifyValues ( ) const

private

Make sure the values we've got are in the range 0 <= x < 2PI.

Definition at line 447 of file Coord.cc.

                                        {
    if (_latitude.asRadians() < -afwGeom::HALFPI || _latitude.asRadians() > afwGeom::HALFPI) {
        throw LSST_EXCEPT(ex::InvalidParameterError,
                          (boost::format("Latitude coord must be: -PI/2 <= lat <= PI/2 (%f).") %
                           _latitude).str());
    }
}

afwGeom::Angle lsst.afw.coord::Coord::angularSeparation

(

Coord const &

c

)

const

compute the angular separation between two Coords

Parameters

c	coordinate to compute our separation from

Definition at line 689 of file Coord.cc.

            {

    // work in Fk5, no matter what two derived classes we're given (eg Fk5 and Galactic)
    // we'll put them in the same system.
    std::pair<afwCoord::Fk5Coord, afwCoord::Fk5Coord> const& fk5 = commonFk5(*this, c);
    afwGeom::Angle const alpha1 = fk5.first.getRa();
    afwGeom::Angle const delta1 = fk5.first.getDec();
    afwGeom::Angle const alpha2 = fk5.second.getRa();
    afwGeom::Angle const delta2 = fk5.second.getDec();

    return haversine(alpha1 - alpha2, delta1 - delta2, std::cos(delta1), std::cos(delta2));
}

virtual Coord::Ptr lsst.afw.coord::Coord::clone ( void  ) const

inlinevirtual

Reimplemented in lsst.afw.coord::TopocentricCoord, lsst.afw.coord::EclipticCoord, lsst.afw.coord::GalacticCoord, lsst.afw.coord::Fk5Coord, and lsst.afw.coord::IcrsCoord.

Definition at line 84 of file Coord.h.

{ return Coord::Ptr(new Coord(*this)); }

afwCoord::Coord::Ptr lsst.afw.coord::Coord::convert

(

CoordSystem

system

)

const

Convert to a specified Coord type.

Definition at line 637 of file Coord.cc.

                                                                {

    switch (system) {
      case FK5:
        {
            Fk5Coord c1 = this->toFk5();
            return boost::shared_ptr<Fk5Coord>(new Fk5Coord(c1.getLongitude(),
                                                            c1.getLatitude(),
                                                            c1.getEpoch()));
        }
        break;
      case ICRS:
        {
            IcrsCoord c2 = this->toIcrs();
            return boost::shared_ptr<IcrsCoord>(new IcrsCoord(c2.getLongitude(),
                                                              c2.getLatitude()));
        }
        break;
      case GALACTIC:
        {
            GalacticCoord c4 = this->toGalactic();
            return boost::shared_ptr<GalacticCoord>(new GalacticCoord(c4.getLongitude(),
                                                                      c4.getLatitude()));
        }
        break;
      case ECLIPTIC:
        {
            EclipticCoord c5 = this->toEcliptic();
            return boost::shared_ptr<EclipticCoord>(new EclipticCoord(c5.getLongitude(),
                                                                      c5.getLatitude(),
                                                                      c5.getEpoch()));
        }
        break;
      case TOPOCENTRIC:
        throw LSST_EXCEPT(ex::InvalidParameterError,
                          "Cannot make Topocentric with convert() (must also specify Observatory).\n"
                          "Instantiate TopocentricCoord() directly.");
        break;
      default:
        throw LSST_EXCEPT(ex::InvalidParameterError,
                          "Undefined CoordSystem: only FK5, ICRS, GALACTIC, ECLIPTIC allowed.");
        break;
        
    }
    
}

virtual std::string lsst.afw.coord::Coord::getClassName ( ) const

inlinevirtual

Reimplemented in lsst.afw.coord::TopocentricCoord, lsst.afw.coord::EclipticCoord, lsst.afw.coord::GalacticCoord, lsst.afw.coord::Fk5Coord, and lsst.afw.coord::IcrsCoord.

Definition at line 101 of file Coord.h.

{ return "Coord"; }

virtual std::pair<std::string, std::string> lsst.afw.coord::Coord::getCoordNames ( ) const

inlinevirtual

Reimplemented in lsst.afw.coord::TopocentricCoord, lsst.afw.coord::EclipticCoord, and lsst.afw.coord::GalacticCoord.

Definition at line 97 of file Coord.h.

                                                                {
        return std::pair<std::string, std::string>("RA", "Dec");
    }

double lsst.afw.coord::Coord::getEpoch ( ) const

inline

Definition at line 93 of file Coord.h.

{ return _epoch; }

lsst::afw::geom::Angle lsst.afw.coord::Coord::getLatitude ( ) const

inline

The main access method for the latitudinal coordinate.

All systems store their latitudinal coordinate in _latitude, be it Dec, b, beta, or altitude. This is how they're accessed.

Definition at line 120 of file Coord.h.

{ return _latitude; };

std::string lsst.afw.coord::Coord::getLatitudeStr ( ) const

inline

Allow quick access to the longitude coordinate as a string.

Note

There's no reason to want a latitude in radians or hours, so the units can not be explicitly requested.

Definition at line 460 of file Coord.h.

                                                         {
    return angleToDmsString(getLatitude());
}

lsst::afw::geom::Angle lsst.afw.coord::Coord::getLongitude ( ) const

inline

The main access method for the longitudinal coordinate.

All systems store their longitudinal coordinate in _longitude, be it RA, l, lambda, or azimuth. This is how they're accessed.

Definition at line 113 of file Coord.h.

{ return _longitude; };

std::string lsst.afw.coord::Coord::getLongitudeStr ( lsst::afw::geom::AngleUnit  unit ) const

inline

Allow quick access to the longitudinal coordinate as a string.

Note

There's no reason to want a longitude in radians, so that unit will cause an exception to be thrown

There's no clear winner for a default, so the unit must always be explicitly provided.

Definition at line 443 of file Coord.h.

                                                                                   {
    if (unit == lsst::afw::geom::hours) {
        return angleToHmsString(getLongitude());
    } else if (unit == lsst::afw::geom::degrees) {
        return angleToDmsString(getLongitude());
    } else {
        throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                          "Units must be 'degrees' or 'hours'");
    }
}

std::pair< afwGeom::Angle, afwGeom::Angle > lsst.afw.coord::Coord::getOffsetFrom

(

afwCoord::Coord const &

c

)

const

Compute the offset from a coordinate.

The resulting angles are suitable for input to Coord::offset

Returns

pair of Angles: bearing (angle wrt a declination parallel) and distance

Parameters

c	Coordinate from which to compute offset

Definition at line 713 of file Coord.cc.

{
    // work in Fk5, no matter what two derived classes we're given (eg Fk5 and Galactic)
    // we'll put them in the same system.
    std::pair<afwCoord::Fk5Coord, afwCoord::Fk5Coord> const& fk5 = commonFk5(*this, c);
    afwGeom::Angle const alpha1 = fk5.first.getRa();
    afwGeom::Angle const delta1 = fk5.first.getDec();
    afwGeom::Angle const alpha2 = fk5.second.getRa();
    afwGeom::Angle const delta2 = fk5.second.getDec();

    afwGeom::Angle const dAlpha = alpha1-alpha2;
    afwGeom::Angle const dDelta = delta1-delta2;

    double const cosDelta1 = std::cos(delta1);
    double const cosDelta2 = std::cos(delta2);

    afwGeom::Angle separation = haversine(dAlpha, dDelta, cosDelta1, cosDelta2);

    // Formula from http://www.movable-type.co.uk/scripts/latlong.html
    double const y = std::sin(dAlpha)*cosDelta2;
    double const x = cosDelta1*std::sin(delta2) - std::sin(delta1)*cosDelta2*std::cos(dAlpha);
    afwGeom::Angle bearing = std::atan2(y, x)*afwGeom::radians - 90.0*afwGeom::degrees;

    return std::make_pair(bearing, separation);
}

afwGeom::Point2D lsst.afw.coord::Coord::getPosition

(

lsst::afw::geom::AngleUnit

unit = lsst::afw::geom::degrees

)

const

Return our contents in a Point2D object.

Definition at line 477 of file Coord.cc.

                                                                     {
    // treat HOURS specially, they must mean hours for RA, degrees for Dec
    if (unit == afwGeom::hours) {
        return afwGeom::Point2D(getLongitude().asHours(), getLatitude().asDegrees());
    } else {
        return afwGeom::Point2D(getLongitude().asAngularUnits(unit), getLatitude().asAngularUnits(unit));
    }
}

std::pair< afwGeom::Angle, afwGeom::Angle > lsst.afw.coord::Coord::getTangentPlaneOffset

(

afwCoord::Coord const &

c

)

const

Get the offset on the tangent plane.

This is suitable only for small angles.

Returns

pair of Angles: Longitude and Latitude offsets

Parameters

c	Coordinate from which to compute offset

Definition at line 748 of file Coord.cc.

{
    // work in Fk5, no matter what two derived classes we're given (eg Fk5 and Galactic)
    // we'll put them in the same system.
    std::pair<afwCoord::Fk5Coord, afwCoord::Fk5Coord> const& fk5 = commonFk5(*this, c);
    afwGeom::Angle const alpha1 = fk5.first.getRa();
    afwGeom::Angle const delta1 = fk5.first.getDec();
    afwGeom::Angle const alpha2 = fk5.second.getRa();
    afwGeom::Angle const delta2 = fk5.second.getDec();

    // This is a projection of coord2 to the tangent plane at coord1
    double const sinDelta1 = std::sin(delta1);
    double const cosDelta1 = std::cos(delta1);
    double const sinDelta2 = std::sin(delta2);
    double const cosDelta2 = std::cos(delta2);
    double const cosAlphaDiff = std::cos(alpha2 - alpha1);
    double const sinAlphaDiff = std::sin(alpha2 - alpha1);

    double const div = cosDelta1 * cosAlphaDiff * cosDelta2 + sinDelta1 * sinDelta2;
    double const xi = cosDelta1 * sinAlphaDiff / div;
    double const eta = (cosDelta1 * cosAlphaDiff * sinDelta2 - sinDelta1 * cosDelta2) / div;

    return std::make_pair(xi*afwGeom::radians, eta*afwGeom::radians);
}

afwGeom::Point3D lsst.afw.coord::Coord::getVector

(

)

const

Return our contents in a position vector.

Definition at line 491 of file Coord.cc.

                                              {
    double lng = getLongitude();
    double lat = getLatitude();
    double const x = std::cos(lng) * std::cos(lat);
    double const y = std::sin(lng) * std::cos(lat);
    double const z = std::sin(lat);
    return afwGeom::Point3D(x, y, z);
}

afwGeom::Angle lsst.afw.coord::Coord::offset	(	lsst::afw::geom::Angle const	phi,
		lsst::afw::geom::Angle const	arcLen
	)

offset our current coords along a great circle defined by an angle wrt a declination parallel

Note

At/near the pole, longitude becomes degenerate with angle-wrt-declination. So at the pole the offset will trace a meridian with longitude = 90 + longitude0 + phi

Returns

the angle wrt a declination parallel at new position

Parameters

phi	angle wrt parallel to offset
arcLen	angle to offset

Definition at line 566 of file Coord.cc.

                                {

    // let v = vector in the direction arcLen points (tangent to surface of sphere)
    // thus: |v| = arcLen
    //       angle phi = orientation of v in a tangent plane, measured wrt to a parallel of declination
    
    // To do the rotation, use rotate() method.
    // - must provide an axis of rotation: take the cross product r x v to get that axis (pole)

    // get the vector r
    Eigen::Vector3d r = getVector().asEigen();

    // Get the vector v:
    // let u = unit vector lying on a parallel of declination
    // let w = unit vector along line of longitude = r x u
    // the vector v must satisfy the following:
    // |v| = arcLen
    // r . v = 0
    // u . v = |v| cos(phi) = arcLen*cos(phi)
    // w . v = |v| sin(phi) = arcLen*sin(phi)

    // v is a linear combination of u and w
    // v = arcLen*cos(phi)*u + arcLen*sin(phi)*w
    
    // Thus, we must:
    // - create u vector
    // - solve w vector (r cross u)
    // - compute v
    Eigen::Vector3d u;
    u << -std::sin(getLongitude()), std::cos(getLongitude()), 0.0;
    Eigen::Vector3d w = r.cross(u);
    Eigen::Vector3d v = arcLen * std::cos(phi)*u + arcLen * std::sin(phi)*w;

    // take r x v to get the axis
    Eigen::Vector3d axisVector = r.cross(v);
    axisVector.normalize();
    Coord axisCoord = Coord(afwGeom::Point3D(axisVector), getEpoch());
    
    rotate(axisCoord, arcLen);
    
    // now get the position angle at our destination
    // u2 . v2 = arcLen*cos(phi2)
    // w2 . v2 = arcLen*sin(phi2)
    // if we normalize v2:
    // phi2 = atan2(w2.v2, u2.v2)
    //
    // we need to compute u2, and then rotate v (exactly as we rotated r) to get v2
    Eigen::Vector3d r2 = getVector().asEigen();
    Eigen::Vector3d u2;
    u2 << -std::sin(getLongitude()), std::cos(getLongitude()), 0.0;
    Eigen::Vector3d w2 = r2.cross(u2);

    // make v a unit vector and rotate v exactly as we rotated r
    v.normalize();
    Coord v2Coord = Coord(afwGeom::Point3D(v), getEpoch());
    v2Coord.rotate(axisCoord, arcLen);
    Eigen::Vector3d v2 = v2Coord.getVector().asEigen();

    afwGeom::Angle phi2 = std::atan2(w2.dot(v2), u2.dot(v2)) * afwGeom::radians;

    return phi2;
}

bool lsst.afw.coord::Coord::operator== ( Coord const &  rhs ) const

inline

Equality operator, compares each element directly.

Definition at line 467 of file Coord.h.

                                                                            {
    return (_longitude == rhs._longitude) &&
        (_latitude == rhs._latitude) &&
        (_epoch == rhs._epoch);
}

lsst::afw::geom::Angle lsst.afw.coord::Coord::operator[] ( int const  index ) const

inline

Provide access to our contents via an index.

Definition at line 418 of file Coord.h.

                                                                           {

    switch (index) {
      case 0:
        return _longitude;
        break;
      case 1:
        return _latitude;
        break;
      default:
        throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                          "Index must be 0 or 1.");
        break;
    }
}

virtual void lsst.afw.coord::Coord::reset ( lsst::afw::geom::Angle const  longitude, lsst::afw::geom::Angle const  latitude  )

inlinevirtual

Reimplemented in lsst.afw.coord::GalacticCoord, and lsst.afw.coord::IcrsCoord.

Definition at line 86 of file Coord.h.

                                                                                          {
        double const epoch = 2000.0;
        reset(longitude, latitude, epoch);
    }

void lsst.afw.coord::Coord::reset ( lsst::afw::geom::Angle const  longitude, lsst::afw::geom::Angle const  latitude, double const  epoch  )

virtual

Reset our coordinates wholesale.

This allows the user to instantiate Coords without values, and fill them later.

Parameters

longitude	Longitude coord (eg. R.A. for Fk5)
latitude	Latitude coord (eg. Declination for Fk5)
epoch	epoch of coordinate

Definition at line 460 of file Coord.cc.

      {
    _longitude = longitude;
    _latitude  = latitude;
    _longitude.wrap();
    _epoch = epoch;
    _verifyValues();
}

void lsst.afw.coord::Coord::rotate	(	Coord const &	axis,
		lsst::afw::geom::Angle const	theta
	)

Rotate our current coords about a pole.

Parameters

axis	axis of rotation (right handed)
theta	angle to offset in radians

Definition at line 529 of file Coord.cc.

                              {

    double const c = std::cos(theta);
    double const mc = 1.0 - c;
    double const s = std::sin(theta);
    
    // convert to cartesian
    afwGeom::Point3D const x = getVector();
    afwGeom::Point3D const u = axis.getVector();
    double const ux = u[0];
    double const uy = u[1];
    double const uz = u[2];

    // rotate
    afwGeom::Point3D xprime;
    xprime[0] = (ux*ux + (1.0 - ux*ux)*c)*x[0] +  (ux*uy*mc - uz*s)*x[1] +  (ux*uz*mc + uy*s)*x[2];
    xprime[1] = (uy*uy + (1.0 - uy*uy)*c)*x[1] +  (uy*uz*mc - ux*s)*x[2] +  (ux*uy*mc + uz*s)*x[0];
    xprime[2] = (uz*uz + (1.0 - uz*uz)*c)*x[2] +  (uz*ux*mc - uy*s)*x[0] +  (uy*uz*mc + ux*s)*x[1];
    
    // in-situ
    std::pair<afwGeom::Angle, afwGeom::Angle> lonLat = pointToLonLat(xprime);
    _longitude = lonLat.first;
    _latitude  = lonLat.second;
}

afwCoord::EclipticCoord lsst.afw.coord::Coord::toEcliptic ( double const  epoch ) const

virtual

Convert ourself to Ecliptic: lambda, beta (precess to new epoch)

Reimplemented in lsst.afw.coord::EclipticCoord, and lsst.afw.coord::Fk5Coord.

Definition at line 806 of file Coord.cc.

                                                                        {
        return this->toFk5(epoch).toEcliptic();
}

afwCoord::EclipticCoord lsst.afw.coord::Coord::toEcliptic ( ) const

virtual

Convert ourself to Ecliptic: lambda, beta (use existing epoch)

Reimplemented in lsst.afw.coord::EclipticCoord, and lsst.afw.coord::Fk5Coord.

Definition at line 812 of file Coord.cc.

                                                      {
        return this->toFk5().toEcliptic();
}

afwCoord::Fk5Coord lsst.afw.coord::Coord::toFk5 ( double const  epoch ) const

virtual

Convert ourself to Fk5: RA, Dec (precess to new epoch)

Reimplemented in lsst.afw.coord::TopocentricCoord, lsst.afw.coord::EclipticCoord, lsst.afw.coord::GalacticCoord, lsst.afw.coord::Fk5Coord, and lsst.afw.coord::IcrsCoord.

Definition at line 778 of file Coord.cc.

                                                              {
    return Fk5Coord(getLongitude(), getLatitude(), getEpoch()).precess(epoch);
}

afwCoord::Fk5Coord lsst.afw.coord::Coord::toFk5 ( ) const

virtual

Convert ourself to Fk5: RA, Dec (use current epoch)

Reimplemented in lsst.afw.coord::TopocentricCoord, lsst.afw.coord::EclipticCoord, lsst.afw.coord::GalacticCoord, lsst.afw.coord::Fk5Coord, and lsst.afw.coord::IcrsCoord.

Definition at line 784 of file Coord.cc.

                                            {
    return Fk5Coord(getLongitude(), getLatitude(), getEpoch());
}

afwCoord::GalacticCoord lsst.afw.coord::Coord::toGalactic ( ) const

virtual

Convert ourself to Galactic: l, b.

Reimplemented in lsst.afw.coord::GalacticCoord, and lsst.afw.coord::Fk5Coord.

Definition at line 799 of file Coord.cc.

                                                      {
    return this->toFk5().toGalactic();
}

afwCoord::IcrsCoord lsst.afw.coord::Coord::toIcrs ( ) const

virtual

Convert ourself to ICRS: RA, Dec (basically J2000)

Reimplemented in lsst.afw.coord::Fk5Coord, and lsst.afw.coord::IcrsCoord.

Definition at line 792 of file Coord.cc.

                                              {
    return this->toFk5().toIcrs();
}

afwCoord::TopocentricCoord lsst.afw.coord::Coord::toTopocentric ( Observatory const &  obs, lsst::daf::base::DateTime const &  obsDate  ) const

virtual

Convert ourself to Altitude/Azimuth: alt, az.

Parameters

obs	observatory of observation
obsDate	date of observation

Reimplemented in lsst.afw.coord::TopocentricCoord, and lsst.afw.coord::Fk5Coord.

Definition at line 819 of file Coord.cc.

                                                                 {
    return this->toFk5().toTopocentric(obs, obsDate);
}

afwCoord::Coord lsst.afw.coord::Coord::transform	(	Coord const &	poleTo,
		Coord const &	poleFrom
	)		const

Tranform our current coords to another spherical polar system.

Variable names assume an equaltorial/galactic tranform, but it works for any spherical polar system when the appropriate poles are supplied.

Parameters

poleTo	Pole of the destination system in the current coords
poleFrom	Pole of the current system in the destination coords

Definition at line 507 of file Coord.cc.

                                                  {
    double const alphaGP  = poleFrom[0];
    double const deltaGP  = poleFrom[1];
    double const lCP      = poleTo[0];
    
    double const alpha = getLongitude();
    double const delta = getLatitude();
    
    afwGeom::Angle const l = (lCP - std::atan2(std::sin(alpha - alphaGP), 
                                               std::tan(delta)*std::cos(deltaGP) - std::cos(alpha - alphaGP)*std::sin(deltaGP))) * afwGeom::radians;
    afwGeom::Angle const b = std::asin( (std::sin(deltaGP)*std::sin(delta) + std::cos(deltaGP)*std::cos(delta)*std::cos(alpha - alphaGP))) * afwGeom::radians;
    return Coord(l, b);
}

Member Data Documentation

double lsst.afw.coord::Coord::_epoch

private

Definition at line 148 of file Coord.h.

lsst::afw::geom::Angle lsst.afw.coord::Coord::_latitude

private

Definition at line 147 of file Coord.h.

lsst::afw::geom::Angle lsst.afw.coord::Coord::_longitude

private

Definition at line 146 of file Coord.h.

---

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

• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/include/lsst/afw/coord/Coord.h
• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/src/coord/Coord.cc