NormalizedAngleInterval.h

Go to the documentation of this file.

/*
 * This file is part of sphgeom.
 *
 * Developed for the LSST Data Management System.
 * This product includes software developed by the LSST Project
 * (http://www.lsst.org).
 * See the COPYRIGHT file at the top-level directory of this distribution
 * for details of code ownership.
 *
 * This software is dual licensed under the GNU General Public License and also
 * under a 3-clause BSD license. Recipients may choose which of these licenses
 * to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
 * respectively.  If you choose the GPL option then the following text applies
 * (but note that there is still no warranty even if you opt for BSD instead):
 *
 * 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 GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#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_