lsst::sphgeom::NormalizedAngleInterval Class Reference

NormalizedAngleInterval represents closed intervals of normalized angles, i.e. More...

#include <NormalizedAngleInterval.h>

Public Member Functions
	NormalizedAngleInterval ()
	This constructor creates an empty interval. More...
	NormalizedAngleInterval (Angle const &x)
	This constructor creates a closed interval containing only the normalization of x. More...
	NormalizedAngleInterval (NormalizedAngle const &x)
	This constructor creates a closed interval containing only x. More...
	NormalizedAngleInterval (Angle x, Angle y)
	This constructor creates an interval from the given endpoints. More...
	NormalizedAngleInterval (NormalizedAngle x, NormalizedAngle y)
	This constructor creates an interval with the given endpoints. More...
bool	operator== (NormalizedAngleInterval const &i) const
	Two intervals are equal if they contain the same points. More...
bool	operator!= (NormalizedAngleInterval const &i) const
bool	operator== (NormalizedAngle x) const
	A closed interval is equal to a point x if both endpoints equal x. More...
bool	operator!= (NormalizedAngle x) const
NormalizedAngle	getA () const
	getA returns the first endpoint of this interval. More...
NormalizedAngle	getB () const
	getB returns the second endpoint of this interval. More...
bool	isEmpty () const
	isEmpty returns true if this interval does not contain any normalized angles. More...
bool	isFull () const
	isFull returns true if this interval contains all normalized angles. More...
bool	wraps () const
	wraps returns true if the interval "wraps" around the 0/2π angle discontinuity, i.e. More...
NormalizedAngle	getCenter () const
	getCenter returns the center of this interval. More...
NormalizedAngle	getSize () const
	getSize returns the size (length, width) of this interval. More...
NormalizedAngleInterval &	clipTo (NormalizedAngle x)
	clipTo shrinks this interval until all its points are in x. More...
NormalizedAngleInterval &	clipTo (NormalizedAngleInterval const &x)
	x.clipTo(y) sets x to the smallest interval containing the intersection of x and y. More...
NormalizedAngleInterval	clippedTo (NormalizedAngle x) const
	clippedTo returns the intersection of this interval and x. More...
NormalizedAngleInterval	clippedTo (NormalizedAngleInterval const &x) const
	clippedTo returns the smallest interval containing the intersection of this interval and x. More...
NormalizedAngleInterval	dilatedBy (Angle x) const
	For positive x, dilatedBy returns the morphological dilation of this interval by [-x,x]. More...
NormalizedAngleInterval	erodedBy (Angle x) const
NormalizedAngleInterval &	dilateBy (Angle x)
NormalizedAngleInterval &	erodeBy (Angle x)
bool	contains (NormalizedAngle x) const
bool	contains (NormalizedAngleInterval const &x) const
bool	isDisjointFrom (NormalizedAngle x) const
bool	isDisjointFrom (NormalizedAngleInterval const &x) const
bool	intersects (NormalizedAngle x) const
bool	intersects (NormalizedAngleInterval const &x) const
bool	isWithin (NormalizedAngle x) const
bool	isWithin (NormalizedAngleInterval const &x) const
Relationship	relate (NormalizedAngle x) const
Relationship	relate (NormalizedAngleInterval const &x) const
NormalizedAngleInterval &	expandTo (NormalizedAngle x)
NormalizedAngleInterval &	expandTo (NormalizedAngleInterval const &x)
NormalizedAngleInterval	expandedTo (NormalizedAngle x) const
NormalizedAngleInterval	expandedTo (NormalizedAngleInterval const &x) const

Static Public Member Functions
static NormalizedAngleInterval	fromDegrees (double a, double b)
static NormalizedAngleInterval	fromRadians (double a, double b)
static NormalizedAngleInterval	empty ()
static NormalizedAngleInterval	full ()

Detailed Description

NormalizedAngleInterval represents closed intervals of normalized angles, i.e.

intervals of the unit circle.

A point on the unit circle is represented by the angle ∈ [0, 2π) between it and a reference point, and an interval by a pair of bounding points a and b. The points in the interval are traced out by counter-clockwise rotation of a around the circle until it reaches b. Because the endpoints are represented via normalized angles, a can be greater than b, indicating that the interval consists of the points represented by angles [a, 2π) ⋃ [0, b]. When this is the case, calling wraps() on the interval will return true.

An interval with identical endpoints contains just that point, and is equal to that point.

An interval with NaN as either endpoint is empty, meaning that it contains no points on the unit circle. The interval [0, 2 * PI] is full, meaning that it contains all representable normalized angles in [0, 2π).

Definition at line 57 of file NormalizedAngleInterval.h.

Constructor & Destructor Documentation

NormalizedAngleInterval() [1/5]

lsst::sphgeom::NormalizedAngleInterval::NormalizedAngleInterval ( )

inline

This constructor creates an empty interval.

Definition at line 79 of file NormalizedAngleInterval.h.

                              :
        _a(NormalizedAngle::nan()), _b(NormalizedAngle::nan()) {}

NormalizedAngleInterval() [2/5]

lsst::sphgeom::NormalizedAngleInterval::NormalizedAngleInterval ( Angle const &  x )

inlineexplicit

This constructor creates a closed interval containing only the normalization of x.

Definition at line 84 of file NormalizedAngleInterval.h.

: _a(x), _b(_a) {}

NormalizedAngleInterval() [3/5]

lsst::sphgeom::NormalizedAngleInterval::NormalizedAngleInterval ( NormalizedAngle const &  x )

inlineexplicit

This constructor creates a closed interval containing only x.

Definition at line 87 of file NormalizedAngleInterval.h.

                                                                :
        _a(x), _b(x) {}

NormalizedAngleInterval() [4/5]

lsst::sphgeom::NormalizedAngleInterval::NormalizedAngleInterval	(	Angle	x,
		Angle	y
	)

This constructor creates an interval from the given endpoints.

If both x and y lie in the range [0, 2π), then y may be less than x. For example, passing in x = 3π/2 and y = π/2 will result in an interval containing angles [3π/2, 2π) ⋃ [0, π/2]. Otherwise, x must be less than or equal to y, and the interval will correspond to the the set of angles produced by normalizing the elements of the interval [x, y].

Definition at line 35 of file NormalizedAngleInterval.cc.

                                                                 {
    if (x.isNan() || y.isNan()) {
        *this = empty();
        return;
    }
    if (!x.isNormalized() || !y.isNormalized()) {
        if (x > y) {
            throw std::invalid_argument(
                "invalid NormalizedAngleInterval endpoints");
        }
        if (y - x >= Angle(2.0 * PI)) {
            *this = full();
            return;
        }
    }
    _a = NormalizedAngle(x);
    _b = NormalizedAngle(y);
}

NormalizedAngleInterval() [5/5]

lsst::sphgeom::NormalizedAngleInterval::NormalizedAngleInterval ( NormalizedAngle  x, NormalizedAngle  y  )

inline

This constructor creates an interval with the given endpoints.

Definition at line 99 of file NormalizedAngleInterval.h.

                                                                  :
        _a(x), _b(y) {}

Member Function Documentation

clippedTo() [1/2]

NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::clippedTo ( NormalizedAngle  x ) const

inline

clippedTo returns the intersection of this interval and x.

Definition at line 214 of file NormalizedAngleInterval.h.

                                                               {
        return contains(x) ? NormalizedAngleInterval(x) : empty();
    }

clippedTo() [2/2]

NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::clippedTo ( NormalizedAngleInterval const &  x ) const

inline

clippedTo returns the smallest interval containing the intersection of this interval and x.

The result is not always unique, and x.clippedTo(y) is not guaranteed to equal y.clippedTo(x).

Definition at line 221 of file NormalizedAngleInterval.h.

                                                                               {
        return NormalizedAngleInterval(*this).clipTo(x);
    }

clipTo() [1/2]

NormalizedAngleInterval & lsst::sphgeom::NormalizedAngleInterval::clipTo ( NormalizedAngle  x )

inline

clipTo shrinks this interval until all its points are in x.

Definition at line 203 of file NormalizedAngleInterval.h.

                                                        {
        *this = clippedTo(x);
        return *this;
    }

clipTo() [2/2]

NormalizedAngleInterval & lsst::sphgeom::NormalizedAngleInterval::clipTo

(

NormalizedAngleInterval const &

x

)

x.clipTo(y) sets x to the smallest interval containing the intersection of x and y.

The result is not always unique, and x.clipTo(y) is not guaranteed to equal y.clipTo(x).

Definition at line 163 of file NormalizedAngleInterval.cc.

{
    if (x.isEmpty()) {
        *this = empty();
    } else if (contains(x._a)) {
        if (contains(x._b)) {
            // Both endpoints of x are in this interval. This interval
            // either contains x, in which case x is the exact intersection,
            // or the intersection consists of [_a,x._b] ⋃ [x._a,_b].
            // In both cases, the envelope of the intersection is the shorter
            // of the two intervals.
            if (getSize() >= x.getSize()) {
                *this = x;
            }
        } else {
            _a = x._a;
        }
    } else if (contains(x._b)) {
        _b = x._b;
    } else if (x.isDisjointFrom(_a)) {
        *this = empty();
    }
    return *this;
}

contains() [1/2]

bool lsst::sphgeom::NormalizedAngleInterval::contains ( NormalizedAngle  x ) const

inline

contains returns true if the intersection of this interval and x is equal to x.

Definition at line 150 of file NormalizedAngleInterval.h.

                                           {
        if (x.isNan()) {
            return true;
        }
        return wraps() ? (x <= _b || _a <= x) : (_a <= x && x <= _b);
    }

contains() [2/2]

bool lsst::sphgeom::NormalizedAngleInterval::contains

(

NormalizedAngleInterval const &

x

)

const

contains returns true if the intersection of this interval and x is equal to x.

Definition at line 54 of file NormalizedAngleInterval.cc.

{
    if (x.isEmpty()) {
        return true;
    }
    if (isEmpty()) {
        return false;
    }
    if (x.wraps()) {
        if (!wraps()) {
            return isFull();
        }
    } else if (wraps()) {
        return x._a >= _a || x._b <= _b;
    }
    return x._a >= _a && x._b <= _b;
}

dilateBy()

NormalizedAngleInterval & lsst::sphgeom::NormalizedAngleInterval::dilateBy ( Angle  x )

inline

Definition at line 253 of file NormalizedAngleInterval.h.

                                                {
        *this = dilatedBy(x);
        return *this;
    }

dilatedBy()

NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::dilatedBy

(

Angle

x

)

const

For positive x, dilatedBy returns the morphological dilation of this interval by [-x,x].

For negative x, it returns the morphological erosion of this interval by [x,-x]. If x is zero or NaN, or this interval is empty, there is no effect.

Definition at line 232 of file NormalizedAngleInterval.cc.

                                                                        {
    if (isEmpty() || isFull() || x == Angle(0.0) || x.isNan()) {
        return *this;
    }
    Angle a = _a - x;
    Angle b = _b + x;
    if (x > Angle(0.0)) {
        // x is a dilation.
        if (x >= Angle(PI)) { return full(); }
        if (wraps()) {
            // The undilated interval wraps. If the dilated one does not,
            // then decreasing a from _a and increasing b from _b has
            // caused b and a to cross.
            if (a <= b) { return full(); }
        } else {
            // The undilated interval does not wrap. If either a or b
            // is not normalized then the dilated interval must either
            // wrap or be full.
            if (a < Angle(0.0)) {
                a = a + Angle(2.0 * PI);
                if (a <= b) { return full(); }
            }
            if (b > Angle(2.0 * PI)) {
                b = b - Angle(2.0 * PI);
                if (a <= b) { return full(); }
            }
        }
    } else {
        // x is an erosion.
        if (x <= Angle(-PI)) { return empty(); }
        if (wraps()) {
            // The uneroded interval wraps. If either a or b is not
            // normalized, then either the eroded interval does not wrap,
            // or it is empty.
            if (a > Angle(2.0 * PI)) {
                a = a - Angle(2.0 * PI);
                if (a > b) { return empty(); }
            }
            if (b < Angle(0.0)) {
                b = b + Angle(2.0 * PI);
                if (a > b) { return empty(); }
            }
        } else {
            // The uneroded interval does not wrap. If the eroded one does,
            // then increasing a from _a and decreasing b from _b has
            // caused a and b to cross.
            if (a > b) { return empty(); }
        }
    }
    return NormalizedAngleInterval(a, b);
}

empty()

static NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::empty ( )

inlinestatic

Definition at line 69 of file NormalizedAngleInterval.h.

                                           {
        return NormalizedAngleInterval();
    }

erodeBy()

NormalizedAngleInterval & lsst::sphgeom::NormalizedAngleInterval::erodeBy ( Angle  x )

inline

Definition at line 258 of file NormalizedAngleInterval.h.

{ return dilateBy(-x); }

erodedBy()

NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::erodedBy ( Angle  x ) const

inline

Definition at line 251 of file NormalizedAngleInterval.h.

{ return dilatedBy(-x); }

expandedTo() [1/2]

NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::expandedTo ( NormalizedAngle  x ) const

inline

expandedTo returns the smallest interval containing the union of this interval and x. The result is not always unique, and x.expandedTo(y) is not guaranteed to equal y.expandedTo(x).

Definition at line 237 of file NormalizedAngleInterval.h.

                                                                {
        return NormalizedAngleInterval(*this).expandTo(x);
    }

expandedTo() [2/2]

NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::expandedTo ( NormalizedAngleInterval const &  x ) const

inline

expandedTo returns the smallest interval containing the union of this interval and x. The result is not always unique, and x.expandedTo(y) is not guaranteed to equal y.expandedTo(x).

Definition at line 241 of file NormalizedAngleInterval.h.

                                                                                {
        return NormalizedAngleInterval(*this).expandTo(x);
    }

expandTo() [1/2]

NormalizedAngleInterval & lsst::sphgeom::NormalizedAngleInterval::expandTo

(

NormalizedAngle

x

)

expandTo minimally expands this interval to contain x. The result is not always unique, and x.expandTo(y) is not guaranteed to equal y.expandTo(x).

Definition at line 189 of file NormalizedAngleInterval.cc.

{
    if (isEmpty()) {
        *this = NormalizedAngleInterval(x);
    } else if (!contains(x)) {
        if (x.getAngleTo(_a) > _b.getAngleTo(x)) {
            _b = x;
        } else {
            _a = x;
        }
    }
    return *this;
}

expandTo() [2/2]

NormalizedAngleInterval & lsst::sphgeom::NormalizedAngleInterval::expandTo

(

NormalizedAngleInterval const &

x

)

expandTo minimally expands this interval to contain x. The result is not always unique, and x.expandTo(y) is not guaranteed to equal y.expandTo(x).

Definition at line 204 of file NormalizedAngleInterval.cc.

{
    if (!x.isEmpty()) {
        if (contains(x._a)) {
            if (contains(x._b)) {
                // Both endpoints of x are in this interval. This interval
                // either contains x, in which case this interval is the
                // desired union, or the union is the full interval.
                if (wraps() != x.wraps()) {
                    *this = full();
                }
            } else {
                _b = x._b;
            }
        } else if (contains(x._b)) {
            _a = x._a;
        } else if (isEmpty() || x.contains(_a)) {
            *this = x;
        } else if (_b.getAngleTo(x._a) < x._b.getAngleTo(_a)) {
            _b = x._b;
        } else {
            _a = x._a;
        }
    }
    return *this;
}

fromDegrees()

static NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::fromDegrees ( double  a, double  b  )

inlinestatic

Definition at line 60 of file NormalizedAngleInterval.h.

                                                                   {
        return NormalizedAngleInterval(Angle::fromDegrees(a),
                                       Angle::fromDegrees(b));
    }

fromRadians()

static NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::fromRadians ( double  a, double  b  )

inlinestatic

Definition at line 65 of file NormalizedAngleInterval.h.

                                                                   {
        return NormalizedAngleInterval(Angle(a), Angle(b));
    }

full()

static NormalizedAngleInterval lsst::sphgeom::NormalizedAngleInterval::full ( )

inlinestatic

Definition at line 73 of file NormalizedAngleInterval.h.

                                          {
        return NormalizedAngleInterval(NormalizedAngle(0.0),
                                       NormalizedAngle(2.0 * PI));
    }

getA()

NormalizedAngle lsst::sphgeom::NormalizedAngleInterval::getA ( ) const

inline

getA returns the first endpoint of this interval.

Definition at line 119 of file NormalizedAngleInterval.h.

{ return _a; }

getB()

NormalizedAngle lsst::sphgeom::NormalizedAngleInterval::getB ( ) const

inline

getB returns the second endpoint of this interval.

Definition at line 122 of file NormalizedAngleInterval.h.

{ return _b; }

getCenter()

NormalizedAngle lsst::sphgeom::NormalizedAngleInterval::getCenter ( ) const

inline

getCenter returns the center of this interval.

It is NaN for empty intervals, and arbitrary for full intervals.

Definition at line 139 of file NormalizedAngleInterval.h.

{ return NormalizedAngle::center(_a, _b); }

getSize()

NormalizedAngle lsst::sphgeom::NormalizedAngleInterval::getSize ( ) const

inline

getSize returns the size (length, width) of this interval.

It is zero for single-point intervals, and NaN for empty intervals. Note that due to rounding errors, an interval with size 2 * PI is not necessarily full, and an interval with size 0 may contain more than a single point.

Definition at line 145 of file NormalizedAngleInterval.h.

{ return _a.getAngleTo(_b); }

intersects() [1/2]

bool lsst::sphgeom::NormalizedAngleInterval::intersects ( NormalizedAngle  x ) const

inline

intersects returns true if the intersection of this interval and x is non-empty.

Definition at line 173 of file NormalizedAngleInterval.h.

                                             {
        return wraps() ? (x <= _b || _a <= x) : (_a <= x && x <= _b);
    }

intersects() [2/2]

bool lsst::sphgeom::NormalizedAngleInterval::intersects ( NormalizedAngleInterval const &  x ) const

inline

intersects returns true if the intersection of this interval and x is non-empty.

Definition at line 177 of file NormalizedAngleInterval.h.

                                                             {
        return !isDisjointFrom(x);
    }

isDisjointFrom() [1/2]

bool lsst::sphgeom::NormalizedAngleInterval::isDisjointFrom ( NormalizedAngle  x ) const

inline

isDisjointFrom returns true if the intersection of this interval and x is empty.

Definition at line 163 of file NormalizedAngleInterval.h.

                                                 {
        return !intersects(x);
    }

isDisjointFrom() [2/2]

bool lsst::sphgeom::NormalizedAngleInterval::isDisjointFrom

(

NormalizedAngleInterval const &

x

)

const

isDisjointFrom returns true if the intersection of this interval and x is empty.

Definition at line 73 of file NormalizedAngleInterval.cc.

{
    if (x.isEmpty() || isEmpty()) {
        return true;
    }
    if (x.wraps()) {
        return wraps() ? false : (x._a > _b && x._b < _a);
    }
    if (wraps()) {
        return _a > x._b && _b < x._a;
    }
    return x._b < _a || x._a > _b;
}

isEmpty()

bool lsst::sphgeom::NormalizedAngleInterval::isEmpty ( ) const

inline

isEmpty returns true if this interval does not contain any normalized angles.

Definition at line 126 of file NormalizedAngleInterval.h.

{ return _a.isNan() || _b.isNan(); }

isFull()

bool lsst::sphgeom::NormalizedAngleInterval::isFull ( ) const

inline

isFull returns true if this interval contains all normalized angles.

Definition at line 129 of file NormalizedAngleInterval.h.

                        {
        return _a.asRadians() == 0.0 && _b.asRadians() == 2.0 * PI;
    }

isWithin() [1/2]

bool lsst::sphgeom::NormalizedAngleInterval::isWithin ( NormalizedAngle  x ) const

inline

isWithin returns true if the intersection of this interval and x is this interval.

Definition at line 185 of file NormalizedAngleInterval.h.

                                           {
        return (_a == x && _b == x) || isEmpty();
    }

isWithin() [2/2]

bool lsst::sphgeom::NormalizedAngleInterval::isWithin ( NormalizedAngleInterval const &  x ) const

inline

isWithin returns true if the intersection of this interval and x is this interval.

Definition at line 189 of file NormalizedAngleInterval.h.

                                                           {
        return x.contains(*this);
    }

operator!=() [1/2]

bool lsst::sphgeom::NormalizedAngleInterval::operator!= ( NormalizedAngle  x ) const

inline

Definition at line 116 of file NormalizedAngleInterval.h.

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

operator!=() [2/2]

bool lsst::sphgeom::NormalizedAngleInterval::operator!= ( NormalizedAngleInterval const &  i ) const

inline

Definition at line 107 of file NormalizedAngleInterval.h.

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

operator==() [1/2]

bool lsst::sphgeom::NormalizedAngleInterval::operator== ( NormalizedAngle  x ) const

inline

A closed interval is equal to a point x if both endpoints equal x.

Definition at line 112 of file NormalizedAngleInterval.h.

                                             {
        return (_a == x && _b == x) || (x.isNan() && isEmpty());
    }

operator==() [2/2]

bool lsst::sphgeom::NormalizedAngleInterval::operator== ( NormalizedAngleInterval const &  i ) const

inline

Two intervals are equal if they contain the same points.

Definition at line 103 of file NormalizedAngleInterval.h.

                                                             {
        return (_a == i._a && _b == i._b) || (isEmpty() && i.isEmpty());
    }

relate() [1/2]

Relationship lsst::sphgeom::NormalizedAngleInterval::relate

(

NormalizedAngle

x

)

const

relate returns a bitset S describing the spatial relationships between this interval and x. For each relation that holds, the bitwise AND of S and the corresponding Relationship will be non-zero.

Definition at line 88 of file NormalizedAngleInterval.cc.

                                                                    {
    if (isEmpty()) {
        if (x.isNan()) {
            return CONTAINS | DISJOINT | WITHIN;
        }
        return DISJOINT | WITHIN;
    }
    if (x.isNan()) {
        return CONTAINS | DISJOINT;
    }
    if (_a == x && _b == x) {
        return CONTAINS | WITHIN;
    }
    if (intersects(x)) {
        return CONTAINS;
    }
    return DISJOINT;
}

relate() [2/2]

Relationship lsst::sphgeom::NormalizedAngleInterval::relate

(

NormalizedAngleInterval const &

x

)

const

relate returns a bitset S describing the spatial relationships between this interval and x. For each relation that holds, the bitwise AND of S and the corresponding Relationship will be non-zero.

Definition at line 107 of file NormalizedAngleInterval.cc.

{
    if (isEmpty()) {
        if (x.isEmpty()) {
            return CONTAINS | DISJOINT | WITHIN;
        }
        return DISJOINT | WITHIN;
    }
    if (x.isEmpty()) {
        return CONTAINS | DISJOINT;
    }
    if (_a == x._a && _b == x._b) {
        return CONTAINS | WITHIN;
    }
    // The intervals are not the same, and neither is empty.
    if (wraps()) {
        if (x.wraps()) {
            // Both intervals wrap.
            if (_a <= x._a && _b >= x._b) {
                return CONTAINS;
            }
            if (_a >= x._a && _b <= x._b) {
                return WITHIN;
            }
            return INTERSECTS;
        }
        // x does not wrap.
        if (x.isFull()) {
            return WITHIN;
        }
        if (_a <= x._a || _b >= x._b) {
            return CONTAINS;
        }
        return (_a > x._b && _b < x._a) ? DISJOINT : INTERSECTS;
    }
    if (x.wraps()) {
        // This interval does not wrap.
        if (isFull()) {
            return CONTAINS;
        }
        if (x._a <= _a || x._b >= _b) {
            return WITHIN;
        }
        return (x._a > _b && x._b < _a) ? DISJOINT : INTERSECTS;
    }
    // Neither interval wraps.
    if (_a <= x._a && _b >= x._b) {
        return CONTAINS;
    }
    if (_a >= x._a && _b <= x._b) {
        return WITHIN;
    }
    return (_a <= x._b && _b >= x._a) ? INTERSECTS : DISJOINT;
}

wraps()

bool lsst::sphgeom::NormalizedAngleInterval::wraps ( ) const

inline

wraps returns true if the interval "wraps" around the 0/2π angle discontinuity, i.e.

consists of [getA(), 2π) ∪ [0, getB()].

Definition at line 135 of file NormalizedAngleInterval.h.

{ return _a > _b; }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-4.0.1/Linux64/sphgeom/ga1cf026fa3+ac198e9f13/include/lsst/sphgeom/NormalizedAngleInterval.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-4.0.1/Linux64/sphgeom/ga1cf026fa3+ac198e9f13/src/NormalizedAngleInterval.cc