lsst::sphgeom::NormalizedAngle Class Reference

NormalizedAngle is an angle that lies in the range [0, 2π), with one exception - a NormalizedAngle can be NaN. More...

#include <NormalizedAngle.h>

Public Member Functions
	NormalizedAngle ()=default
	This constructor creates a NormalizedAngle with a value of zero.
	NormalizedAngle (NormalizedAngle const &a)=default
	This constructor creates a copy of a.
	NormalizedAngle (Angle const &a)
	This constructor creates a normalized copy of a.
	NormalizedAngle (double a)
	This constructor creates a NormalizedAngle with the given value in radians, normalized to be in the range [0, 2π).
	NormalizedAngle (LonLat const &, LonLat const &)
	This constructor creates a NormalizedAngle equal to the angle between the given points on the unit sphere.
	NormalizedAngle (Vector3d const &, Vector3d const &)
	This constructor creates a NormalizedAngle equal to the angle between the given 3-vectors, which need not have unit norm.
	operator Angle const & () const
	This conversion operator returns a const reference to the underlying Angle.
bool	operator== (Angle const &a) const
bool	operator!= (Angle const &a) const
bool	operator< (Angle const &a) const
bool	operator> (Angle const &a) const
bool	operator<= (Angle const &a) const
bool	operator>= (Angle const &a) const
Angle	operator- () const
Angle	operator+ (Angle const &a) const
Angle	operator- (Angle const &a) const
Angle	operator* (double a) const
Angle	operator/ (double a) const
double	operator/ (Angle const &a) const
double	asDegrees () const
	asDegrees returns the value of this angle in units of degrees.
double	asRadians () const
	asRadians returns the value of this angle in units of radians.
bool	isNan () const
	isNan returns true if the angle value is NaN.
NormalizedAngle	getAngleTo (NormalizedAngle const &a) const
	getAngleTo computes the angle α ∈ [0, 2π) such that adding α to this angle and then normalizing the result yields a.

Static Public Member Functions
static NormalizedAngle	nan ()
static NormalizedAngle	fromDegrees (double a)
static NormalizedAngle	fromRadians (double a)
static NormalizedAngle	between (NormalizedAngle const &a, NormalizedAngle const &b)
	For two angles a and b, between(a, b) returns the smaller of a.getAngleTo(b) and b.getAngleTo(a).
static NormalizedAngle	center (NormalizedAngle const &a, NormalizedAngle const &b)
	For two normalized angles a and b, center(a, b) returns the angle m such that a.getAngleTo(m) is equal to m.getAngleTo(b).

Detailed Description

NormalizedAngle is an angle that lies in the range [0, 2π), with one exception - a NormalizedAngle can be NaN.

Definition at line 50 of file NormalizedAngle.h.

Constructor & Destructor Documentation

NormalizedAngle() [1/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle ( )

default

This constructor creates a NormalizedAngle with a value of zero.

NormalizedAngle() [2/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle ( NormalizedAngle const & a )

default

This constructor creates a copy of a.

NormalizedAngle() [3/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle ( Angle const & a )

inlineexplicit

This constructor creates a normalized copy of a.

Definition at line 86 of file NormalizedAngle.h.

                                              {
        *this = NormalizedAngle(a.asRadians());
    }

NormalizedAngle() [4/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle ( double a )

inlineexplicit

This constructor creates a NormalizedAngle with the given value in radians, normalized to be in the range [0, 2π).

Definition at line 92 of file NormalizedAngle.h.

                                       {
        // For really large |a|, the error in this reduction can exceed 2*PI
        // (because PI is only an approximation to π).
        if (a < 0.0) {
            _a = Angle(std::fmod(a, 2.0 * PI) + 2.0 * PI);
        } else if (a > 2 * PI) {
            _a = Angle(std::fmod(a, 2.0 * PI));
        } else {
            _a = Angle(a);
        }
    }

NormalizedAngle() [5/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle	(	LonLat const &	p1,
		LonLat const &	p2 )

This constructor creates a NormalizedAngle equal to the angle between the given points on the unit sphere.

Definition at line 66 of file NormalizedAngle.cc.

                                                                     {
    double x = sin((p1.getLon() - p2.getLon()) * 0.5);
    x *= x;
    double y = sin((p1.getLat() - p2.getLat()) * 0.5);
    y *= y;
    double z = cos((p1.getLat() + p2.getLat()) * 0.5);
    z *= z;
    // Compute the square of the sine of half of the desired angle. This is
    // easily shown to be be one fourth of the squared Euclidian distance
    // (chord length) between p1 and p2.
    double sha2 = (x * (z - y) + y);
    // Avoid domain errors in asin and sqrt due to rounding errors.
    if (sha2 < 0.0) {
        _a = Angle(0.0);
    } else if (sha2 >= 1.0) {
        _a = Angle(PI);
    } else {
        _a = Angle(2.0 * std::asin(std::sqrt(sha2)));
    }
}

NormalizedAngle() [6/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle	(	Vector3d const &	v1,
		Vector3d const &	v2 )

This constructor creates a NormalizedAngle equal to the angle between the given 3-vectors, which need not have unit norm.

Definition at line 87 of file NormalizedAngle.cc.

                                                                         {
    double s = v1.cross(v2).getNorm();
    double c = v1.dot(v2);
    if (s == 0.0 && c == 0.0) {
        // Avoid the atan2(±0, -0) = ±PI special case.
        _a = Angle(0.0);
    } else {
        _a = Angle(std::atan2(s, c));
    }
}

Member Function Documentation

asDegrees()

double lsst::sphgeom::NormalizedAngle::asDegrees ( ) const

inline

asDegrees returns the value of this angle in units of degrees.

Definition at line 134 of file NormalizedAngle.h.

{ return _a.asDegrees(); }

asRadians()

double lsst::sphgeom::NormalizedAngle::asRadians ( ) const

inline

asRadians returns the value of this angle in units of radians.

Definition at line 137 of file NormalizedAngle.h.

{ return _a.asRadians(); }

between()

NormalizedAngle lsst::sphgeom::NormalizedAngle::between ( NormalizedAngle const & a, NormalizedAngle const & b )

static

For two angles a and b, between(a, b) returns the smaller of a.getAngleTo(b) and b.getAngleTo(a).

The result will be in the range [0, π].

If one interprets an angle in [0, 2π) as a point on the unit circle, then between can be thought of as computing the arc length of the shortest unit circle segment between the points for a and b.

Definition at line 42 of file NormalizedAngle.cc.

{
    NormalizedAngle x;
    double a1 = std::fabs(a.asRadians() - b.asRadians());
    double a2 = 2.0 * PI - a1;
    x._a = Angle(std::min(a1, a2));
    return x;
}

center()

NormalizedAngle lsst::sphgeom::NormalizedAngle::center ( NormalizedAngle const & a, NormalizedAngle const & b )

static

For two normalized angles a and b, center(a, b) returns the angle m such that a.getAngleTo(m) is equal to m.getAngleTo(b).

Definition at line 52 of file NormalizedAngle.cc.

{
    NormalizedAngle x;
    double c = 0.5 * (a.asRadians() + b.asRadians());
    if (a <= b) {
        x._a = Angle(c);
    } else {
        // The result is (a + b + 2π) / 2, normalized to [0, 2π)
        x._a = Angle((c < PI) ? (c + PI) : (c - PI));
    }
    return x;
}

fromDegrees()

static NormalizedAngle lsst::sphgeom::NormalizedAngle::fromDegrees ( double a )

inlinestatic

Definition at line 56 of file NormalizedAngle.h.

                                                 {
        return NormalizedAngle(a * RAD_PER_DEG);
    }

fromRadians()

static NormalizedAngle lsst::sphgeom::NormalizedAngle::fromRadians ( double a )

inlinestatic

Definition at line 60 of file NormalizedAngle.h.

                                                 {
        return NormalizedAngle(a);
    }

getAngleTo()

NormalizedAngle lsst::sphgeom::NormalizedAngle::getAngleTo ( NormalizedAngle const & a ) const

inline

getAngleTo computes the angle α ∈ [0, 2π) such that adding α to this angle and then normalizing the result yields a.

If one interprets an angle in [0, 2π) as a point on the unit circle, then this method can be thought of as computing the positive rotation angle required to map this point to a.

Definition at line 148 of file NormalizedAngle.h.

                                                                {
        NormalizedAngle x;
        double d = a.asRadians() - asRadians();
        x._a = Angle((d < 0.0) ? 2.0 * PI + d : d);
        return x;
    }

isNan()

bool lsst::sphgeom::NormalizedAngle::isNan ( ) const

inline

isNan returns true if the angle value is NaN.

Definition at line 140 of file NormalizedAngle.h.

{ return _a.isNan(); }

nan()

static NormalizedAngle lsst::sphgeom::NormalizedAngle::nan ( )

inlinestatic

Definition at line 52 of file NormalizedAngle.h.

                                 {
        return NormalizedAngle(std::numeric_limits<double>::quiet_NaN());
    }

operator Angle const &()

lsst::sphgeom::NormalizedAngle::operator Angle const & ( ) const

inline

This conversion operator returns a const reference to the underlying Angle.

It allows a NormalizedAngle to transparently replace an Angle as an argument in most function calls.

Definition at line 115 of file NormalizedAngle.h.

{ return _a; }

operator!=()

bool lsst::sphgeom::NormalizedAngle::operator!= ( Angle const & a ) const

inline

Definition at line 119 of file NormalizedAngle.h.

{ return _a != a; }

operator*()

Angle lsst::sphgeom::NormalizedAngle::operator* ( double a ) const

inline

Definition at line 129 of file NormalizedAngle.h.

{ return _a * a; }

operator+()

Angle lsst::sphgeom::NormalizedAngle::operator+ ( Angle const & a ) const

inline

Definition at line 127 of file NormalizedAngle.h.

{ return _a + a; }

operator-() [1/2]

Angle lsst::sphgeom::NormalizedAngle::operator- ( ) const

inline

Definition at line 126 of file NormalizedAngle.h.

{ return Angle(-_a); }

operator-() [2/2]

Angle lsst::sphgeom::NormalizedAngle::operator- ( Angle const & a ) const

inline

Definition at line 128 of file NormalizedAngle.h.

{ return _a - a; }

operator/() [1/2]

double lsst::sphgeom::NormalizedAngle::operator/ ( Angle const & a ) const

inline

Definition at line 131 of file NormalizedAngle.h.

{ return _a / a; }

operator/() [2/2]

Angle lsst::sphgeom::NormalizedAngle::operator/ ( double a ) const

inline

Definition at line 130 of file NormalizedAngle.h.

{ return _a / a; }

operator<()

bool lsst::sphgeom::NormalizedAngle::operator< ( Angle const & a ) const

inline

Definition at line 120 of file NormalizedAngle.h.

{ return _a < a; }

operator<=()

bool lsst::sphgeom::NormalizedAngle::operator<= ( Angle const & a ) const

inline

Definition at line 122 of file NormalizedAngle.h.

{ return _a <= a; }

operator==()

bool lsst::sphgeom::NormalizedAngle::operator== ( Angle const & a ) const

inline

Definition at line 118 of file NormalizedAngle.h.

{ return _a == a; }

operator>()

bool lsst::sphgeom::NormalizedAngle::operator> ( Angle const & a ) const

inline

Definition at line 121 of file NormalizedAngle.h.

{ return _a > a; }

operator>=()

bool lsst::sphgeom::NormalizedAngle::operator>= ( Angle const & a ) const

inline

Definition at line 123 of file NormalizedAngle.h.

{ return _a >= a; }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/sphgeom/g7b71ed6315+fcb1d3bbc8/include/lsst/sphgeom/NormalizedAngle.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/sphgeom/g7b71ed6315+fcb1d3bbc8/src/NormalizedAngle.cc