NormalizedAngleInterval.h

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 2014-2015 AURA/LSST.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <https://www.lsstcorp.org/LegalNotices/>.
 */
 
#ifndef LSST_SPHGEOM_NORMALIZEDANGLEINTERVAL_H_
#define LSST_SPHGEOM_NORMALIZEDANGLEINTERVAL_H_
 
 
#include <iosfwd>
 
#include "NormalizedAngle.h"
#include "Relationship.h"
 
 
namespace lsst {
namespace sphgeom {
 
class NormalizedAngleInterval {
public:
    // Factory functions
    static NormalizedAngleInterval fromDegrees(double a, double b) {
        return NormalizedAngleInterval(Angle::fromDegrees(a),
                                       Angle::fromDegrees(b));
    }
 
    static NormalizedAngleInterval fromRadians(double a, double b) {
        return NormalizedAngleInterval(Angle(a), Angle(b));
    }
 
    static NormalizedAngleInterval empty() {
        return NormalizedAngleInterval();
    }
 
    static NormalizedAngleInterval full() {
        return NormalizedAngleInterval(NormalizedAngle(0.0),
                                       NormalizedAngle(2.0 * PI));
    }
 
    NormalizedAngleInterval() :
        _a(NormalizedAngle::nan()), _b(NormalizedAngle::nan()) {}
 
    explicit NormalizedAngleInterval(Angle const & x) : _a(x), _b(_a) {}
 
    explicit NormalizedAngleInterval(NormalizedAngle const & x) :
        _a(x), _b(x) {}
 
    NormalizedAngleInterval(Angle x, Angle y);
 
    NormalizedAngleInterval(NormalizedAngle x, NormalizedAngle y) :
        _a(x), _b(y) {}
 
    bool operator==(NormalizedAngleInterval const & i) const {
        return (_a == i._a && _b == i._b) || (isEmpty() && i.isEmpty());
    }
 
    bool operator!=(NormalizedAngleInterval const & i) const {
        return !(*this == i);
    }
 
    bool operator==(NormalizedAngle x) const {
        return (_a == x && _b == x) || (x.isNan() && isEmpty());
    }
 
    bool operator!=(NormalizedAngle x) const { return !(*this == x); }
 
    NormalizedAngle getA() const { return _a; }
 
    NormalizedAngle getB() const { return _b; }
 
    bool isEmpty() const { return _a.isNan() || _b.isNan(); }
 
    bool isFull() const {
        return _a.asRadians() == 0.0 && _b.asRadians() == 2.0 * PI;
    }
 
    bool wraps() const { return _a > _b; }
 
    NormalizedAngle getCenter() const { return NormalizedAngle::center(_a, _b); }
 
    NormalizedAngle getSize() const { return _a.getAngleTo(_b); }
 
    bool contains(NormalizedAngle x) const {
        if (x.isNan()) {
            return true;
        }
        return wraps() ? (x <= _b || _a <= x) : (_a <= x && x <= _b);
    }
 
    bool contains(NormalizedAngleInterval const & x) const;
 
    bool isDisjointFrom(NormalizedAngle x) const {
        return !intersects(x);
    }
 
    bool isDisjointFrom(NormalizedAngleInterval const & x) const;
 
    bool intersects(NormalizedAngle x) const {
        return wraps() ? (x <= _b || _a <= x) : (_a <= x && x <= _b);
    }
 
    bool intersects(NormalizedAngleInterval const & x) const {
        return !isDisjointFrom(x);
    }
 
    bool isWithin(NormalizedAngle x) const {
        return (_a == x && _b == x) || isEmpty();
    }
 
    bool isWithin(NormalizedAngleInterval const & x) const {
        return x.contains(*this);
    }
 
    Relationship relate(NormalizedAngle x) const;
    Relationship relate(NormalizedAngleInterval const & x) const;
 
    NormalizedAngleInterval & clipTo(NormalizedAngle x) {
        *this = clippedTo(x);
        return *this;
    }
 
    NormalizedAngleInterval & clipTo(NormalizedAngleInterval const & x);
 
    NormalizedAngleInterval clippedTo(NormalizedAngle x) const {
        return contains(x) ? NormalizedAngleInterval(x) : empty();
    }
 
    NormalizedAngleInterval clippedTo(NormalizedAngleInterval const & x) const {
        return NormalizedAngleInterval(*this).clipTo(x);
    }
 
    NormalizedAngleInterval & expandTo(NormalizedAngle x);
    NormalizedAngleInterval & expandTo(NormalizedAngleInterval const & x);
 
    NormalizedAngleInterval expandedTo(NormalizedAngle x) const {
        return NormalizedAngleInterval(*this).expandTo(x);
    }
 
    NormalizedAngleInterval expandedTo(NormalizedAngleInterval const & x) const {
        return NormalizedAngleInterval(*this).expandTo(x);
    }
 
    NormalizedAngleInterval dilatedBy(Angle x) const;
    NormalizedAngleInterval erodedBy(Angle x) const { return dilatedBy(-x); }
 
    NormalizedAngleInterval & dilateBy(Angle x) {
        *this = dilatedBy(x);
        return *this;
    }
 
    NormalizedAngleInterval & erodeBy(Angle x) { return dilateBy(-x); }
 
private:
    NormalizedAngle _a;
    NormalizedAngle _b;
};
 
std::ostream & operator<<(std::ostream &, NormalizedAngleInterval const &);
 
}} // namespace lsst::sphgeom
 
#endif // LSST_SPHGEOM_NORMALIZEDANGLEINTERVAL_H_