Loading...
Searching...
No Matches
Projection.h
Go to the documentation of this file.
//# Projection.h: Geometric parameters needed for a sky projection to a plane
//# Copyright (C) 1997,1998,1999,2000,2001,2003
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//# Internet email: casa-feedback@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
#ifndef COORDINATES_PROJECTION_H
#define COORDINATES_PROJECTION_H
#include <casacore/casa/aips.h>
#include <casacore/casa/Arrays/Vector.h>
#include <casacore/casa/BasicSL/String.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <summary>
// Geometric parameters needed for a sky projection to a plane
// </summary>
// <use visibility=export>
// <reviewed reviewer="Peter Barnes" date="1999/12/24" tests="tProjection">
// </reviewed>
//
// <prerequisite>
// <li> Knowledge of astronomical coordinate conversions in general. Probably the
// best documents are the papers by Mark Calabretta and Eric Greisen.
// The initial draft from 1996 can be found at
// http://www.atnf.csiro.au/~mcalabre. It is this draft that the
// Coordinate classes are based upon. Since then, this paper has evolved
// into three which can be found at the above address, and will be published in the
// Astronomy and Astrophysics Supplement Series (probably in 2000).
// The design has changed since the initial draft. When these papers
// are finalized, and the IAU has ratified the new standards, WCSLIB
// (Mark Calabretta's implementation of these conventions) will be
// revised for the new designs. At that time, the Coordinate classes
// may also be revised.
// </prerequisite>
//
// <synopsis>
// This class is used to hold:
// <ol>
// <li> The type of the projection (e.g. SIN); and
// <li> The parameters of the projection, if any. These parameters are described
// by Calabretta and Greisen (called PROJP) in the 1996 draft.
// In the recent versions, this paper has split into three, and the
// projection parameters have been reworked into the PV matrix.
// However, these have not yet been implemented in WCSLIB so we
// stick with the old ones for now.
// </ol>
// </synopsis>
//
// <example>
// <srcblock>
// Projection proj(Projection::CAR);
// cerr << proj.parameters() << endl;
// </srcblock>
// This projection requires no parameters so the printed parameter
// vector would be of zero length.
// </example>
//
// <thrown>
// <li> AipsError
// </thrown>
//
// <todo asof="2000/01/01">
// <li> Worry about projection parameters which are unit dependent (i.e.
// radians vs. degrees).
// <li> LONGPOLE should probably go in here.
// </todo>
//
class Projection
{
public:
// Hold all the known types of celestial projections.
enum Type {
// Zenithal/Azimuthal perspective.
AZP,
// Slant zenithal perspective, new
SZP,
// Gnomonic.
TAN,
// Orthographics/synthesis.
SIN,
// Stereographic.
STG,
// zenith/azimuthal equidistant.
ARC,
// zenithal/azimuthal polynomial.
ZPN,
// zenithal/azimuthal equal area.
ZEA,
// Airy.
AIR,
// Cylindrical perspective.
CYP,
// Plate carree
CAR,
// Mercator.
MER,
// Cylindrical equal area.
CEA,
// Conic perspective.
COP,
// Conic equidistant.
COD,
// Conic equal area.
COE,
// Conic orthomorphic.
COO,
// Bonne.
BON,
// Polyconic.
PCO,
// Sanson-Flamsteed (global sinusoidal).
// The old GLS projection is now SFL. The 'GLS'
// string will be converted to 'SFL'
SFL,
// Parabolic.
PAR,
// Hammer-Aitoff.
AIT,
// Mollweide.
MOL,
// COBE quadrilateralized spherical cube.
CSC,
// Quadrilateralized spherical cube.
QSC,
// Tangential spherical cube.
TSC,
// HEALPix grid
HPX,
// N_PROJ gives the number of supported projections - it shouldn't be used
// as a projection
N_PROJ };
// Construct a projection which needs no parameters. SIN is unique in that
// it can be created with 0 or 2 parameters.
Projection(Projection::Type which=CAR);
// Construct a projection from FITS CTYPE keywords
Projection(const String& ctypeLin, const String& ctypeLat,
const Vector<Double>& parameters);
// Construct a projection which needs parameters. The parameter vector must be
// the length of the required number of parameters.
Projection(Projection::Type which, const Vector<Double> &parameters);
// Copy constructor (copy semantics).
Projection(const Projection &other);
// Assignment (copy semantics)
Projection &operator=(const Projection &other);
// Destructor
~Projection();
// What is the Type of this projection?
Projection::Type type() const;
// What is the type of this projection as a String (e.g. "SIN").
// <group>
String name() const;
static String name(Projection::Type proj);
// </group>
// Turn a projection type name into a Type.
// Returns N_PROJ if the projection is not known.
static Projection::Type type(const String &name);
// How many parameters does this projection have at most?
// What is the minimum number of parameters that have to be supplied?
// What are the parameter values?
// <group>
static uInt nParameters(Projection::Type proj);
static uInt nMinParameters(Projection::Type proj);
const Vector<Double> &parameters() const;
// </group>
// Comparison to fractional tolerance.
Bool near(const Projection &other, Double tol=1.0e-6) const;
// Is this projection a 'zenithal' projection
static Bool isZenithal (Projection::Type proj);
private:
Projection::Type which_p;
Vector<Double> parameters_p;
void validate(const Bool verbose=False);
Projection::Type type (String& ctypeLong, String& ctypeLat) const;
};
//#---------- Inlines --------------------------------------------------------------
inline Projection::Type Projection::type() const {return which_p;}
inline const Vector<Double> & Projection::parameters() const {return parameters_p;}
} //# NAMESPACE CASACORE - END
#endif
casacore::Projection::parameters
const Vector< Double > & parameters() const
Definition Projection.h:217
casacore::Projection::isZenithal
static Bool isZenithal(Projection::Type proj)
Is this projection a 'zenithal' projection.
casacore::Projection::nMinParameters
static uInt nMinParameters(Projection::Type proj)
casacore::Projection::Type
Type
Hold all the known types of celestial projections.
Definition Projection.h:97
casacore::Projection::BON
@ BON
Bonne.
Definition Projection.h:133
casacore::Projection::CSC
@ CSC
COBE quadrilateralized spherical cube.
Definition Projection.h:147
casacore::Projection::COP
@ COP
Conic perspective.
Definition Projection.h:125
casacore::Projection::CAR
@ CAR
Plate carree.
Definition Projection.h:119
casacore::Projection::COO
@ COO
Conic orthomorphic.
Definition Projection.h:131
casacore::Projection::AIT
@ AIT
Hammer-Aitoff.
Definition Projection.h:143
casacore::Projection::SZP
@ SZP
Slant zenithal perspective, new.
Definition Projection.h:101
casacore::Projection::PCO
@ PCO
Polyconic.
Definition Projection.h:135
casacore::Projection::COE
@ COE
Conic equal area.
Definition Projection.h:129
casacore::Projection::MER
@ MER
Mercator.
Definition Projection.h:121
casacore::Projection::ZPN
@ ZPN
zenithal/azimuthal polynomial.
Definition Projection.h:111
casacore::Projection::TSC
@ TSC
Tangential spherical cube.
Definition Projection.h:151
casacore::Projection::AIR
@ AIR
Airy.
Definition Projection.h:115
casacore::Projection::ARC
@ ARC
zenith/azimuthal equidistant.
Definition Projection.h:109
casacore::Projection::QSC
@ QSC
Quadrilateralized spherical cube.
Definition Projection.h:149
casacore::Projection::CYP
@ CYP
Cylindrical perspective.
Definition Projection.h:117
casacore::Projection::ZEA
@ ZEA
zenithal/azimuthal equal area.
Definition Projection.h:113
casacore::Projection::CEA
@ CEA
Cylindrical equal area.
Definition Projection.h:123
casacore::Projection::MOL
@ MOL
Mollweide.
Definition Projection.h:145
casacore::Projection::SFL
@ SFL
Sanson-Flamsteed (global sinusoidal).
Definition Projection.h:139
casacore::Projection::AZP
@ AZP
Zenithal/Azimuthal perspective.
Definition Projection.h:99
casacore::Projection::TAN
@ TAN
Gnomonic.
Definition Projection.h:103
casacore::Projection::SIN
@ SIN
Orthographics/synthesis.
Definition Projection.h:105
casacore::Projection::STG
@ STG
Stereographic.
Definition Projection.h:107
casacore::Projection::PAR
@ PAR
Parabolic.
Definition Projection.h:141
casacore::Projection::HPX
@ HPX
HEALPix grid.
Definition Projection.h:153
casacore::Projection::COD
@ COD
Conic equidistant.
Definition Projection.h:127
casacore::Projection::N_PROJ
@ N_PROJ
N_PROJ gives the number of supported projections - it shouldn't be used as a projection.
Definition Projection.h:156
casacore::Projection::Projection
Projection(const String &ctypeLin, const String &ctypeLat, const Vector< Double > &parameters)
Construct a projection from FITS CTYPE keywords.
casacore::Projection::Projection
Projection(Projection::Type which, const Vector< Double > &parameters)
Construct a projection which needs parameters.
casacore::Projection::nParameters
static uInt nParameters(Projection::Type proj)
How many parameters does this projection have at most?
casacore::Projection::~Projection
~Projection()
Destructor.
casacore::Projection::operator=
Projection & operator=(const Projection &other)
Assignment (copy semantics).
casacore::Projection::near
Bool near(const Projection &other, Double tol=1.0e-6) const
Comparison to fractional tolerance.
casacore::Projection::type
static Projection::Type type(const String &name)
Turn a projection type name into a Type.
casacore::Projection::which_p
Projection::Type which_p
Definition Projection.h:208
casacore::Projection::type
Projection::Type type(String &ctypeLong, String &ctypeLat) const
casacore::Projection::parameters_p
Vector< Double > parameters_p
Definition Projection.h:209
casacore::Projection::name
String name() const
What is the type of this projection as a String (e.g.
casacore::Projection::Projection
Projection(Projection::Type which=CAR)
Construct a projection which needs no parameters.
casacore::Projection::Projection
Projection(const Projection &other)
Copy constructor (copy semantics).
casacore::Projection::type
Projection::Type type() const
What is the Type of this projection?
Definition Projection.h:216
casacore::Projection::validate
void validate(const Bool verbose=False)
casacore::Projection::name
static String name(Projection::Type proj)
casacore::String
String: the storage and methods of handling collections of characters.
Definition String.h:223
casacore::Vector
Definition Vector.h:82
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::False
const Bool False
Definition aipstype.h:42
casacore::uInt
unsigned int uInt
Definition aipstype.h:49
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::Double
double Double
Definition aipstype.h:53