Ellipse.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_ELLIPSE_H_
#define LSST_SPHGEOM_ELLIPSE_H_
 
 
#include <iosfwd>
#include <limits>
 
#include "Circle.h"
#include "Matrix3d.h"
#include "Region.h"
#include "UnitVector3d.h"
 
 
namespace lsst {
namespace sphgeom {
 
class Ellipse : public Region {
public:
    static constexpr std::uint8_t TYPE_CODE = 'e';
 
    static Ellipse empty() { return Ellipse(); }
 
    static Ellipse full() { return Ellipse().complement(); }
 
    Ellipse() :
        _S(1.0),
        _a(-2.0),
        _b(-2.0),
        _gamma(0.0),
        _tana(std::numeric_limits<double>::infinity()),
        _tanb(std::numeric_limits<double>::infinity())
    {}
 
    explicit Ellipse(Circle const & c) {
        *this = Ellipse(c.getCenter(), c.getCenter(), c.getOpeningAngle());
    }
 
    explicit Ellipse(UnitVector3d const & v, Angle alpha = Angle(0.0)) {
        *this = Ellipse(v, v, alpha);
    }
 
    Ellipse(UnitVector3d const & f1, UnitVector3d const & f2, Angle alpha);
 
    Ellipse(UnitVector3d const & center,
            Angle alpha,
            Angle beta,
            Angle orientation);
 
    bool operator==(Ellipse const & e) const {
        return _S == e._S && _a == e._a && _b == e._b;
    }
 
    bool operator!=(Ellipse const & e) const { return !(*this == e); }
 
    bool isEmpty() const override { return Angle(0.5 * PI) + _a < _gamma; }
 
    bool isFull() const { return Angle(0.5 * PI) - _a <= _gamma; }
 
    bool isGreatCircle() const { return _a.asRadians() == 0.0; }
 
    bool isCircle() const { return _a == _b; }
 
    Matrix3d const & getTransformMatrix() const { return _S; }
 
    UnitVector3d getCenter() const {
        return UnitVector3d::fromNormalized(_S(2,0), _S(2,1), _S(2,2));
    }
 
    UnitVector3d getF1() const {
        UnitVector3d n = UnitVector3d::fromNormalized(_S(1,0), _S(1,1), _S(1,2));
        return getCenter().rotatedAround(n, -_gamma);
    }
 
    UnitVector3d getF2() const {
        UnitVector3d n = UnitVector3d::fromNormalized(_S(1,0), _S(1,1), _S(1,2));
        return getCenter().rotatedAround(n, _gamma);
    }
 
    Angle getAlpha() const { return Angle(0.5 * PI) + _a; }
 
    Angle getBeta() const { return Angle(0.5 * PI) + _b; }
 
    Angle getGamma() const { return _gamma; }
 
    Ellipse & complement() {
        _S = Matrix3d(-_S(0,0), -_S(0,1), -_S(0,2),
                       _S(1,0),  _S(1,1),  _S(1,2),
                      -_S(2,0), -_S(2,1), -_S(2,2));
        _a = -_a;
        _b = -_b;
        return *this;
    }
 
    Ellipse complemented() const { return Ellipse(*this).complement(); }
 
    // Region interface
    std::unique_ptr<Region> clone() const override {
        return std::unique_ptr<Ellipse>(new Ellipse(*this));
    }
 
    Box getBoundingBox() const override;
    Box3d getBoundingBox3d() const override;
    Circle getBoundingCircle() const override;
 
    bool contains(UnitVector3d const &v) const override;
 
    using Region::contains;
 
    Relationship relate(Region const & r) const override {
        // Dispatch on the type of r.
        return invert(r.relate(*this));
    }
 
    Relationship relate(Box const &) const override;
    Relationship relate(Circle const &) const override;
    Relationship relate(ConvexPolygon const &) const override;
    Relationship relate(Ellipse const &) const override;
 
    TriState overlaps(Region const& other) const override {
        return other.overlaps(*this);
    }
    TriState overlaps(Box const &) const override;
    TriState overlaps(Circle const &) const override;
    TriState overlaps(ConvexPolygon const &) const override;
    TriState overlaps(Ellipse const &) const override;
 
    std::vector<std::uint8_t> encode() const override;
 
    static std::unique_ptr<Ellipse> decode(std::vector<std::uint8_t> const & s) {
        return decode(s.data(), s.size());
    }
    static std::unique_ptr<Ellipse> decode(std::uint8_t const * buffer, size_t n);
 
private:
    static constexpr size_t ENCODED_SIZE = 113;
 
    Matrix3d _S;
    Angle _a; // α - π/2
    Angle _b; // β - π/2
    Angle _gamma; // Half the angle between the ellipse foci
    double _tana; // |tan a| = |cot α|
    double _tanb; // |tan b| = |cot β|
};
 
std::ostream & operator<<(std::ostream &, Ellipse const &);
 
}} // namespace lsst::sphgeom
 
#endif // LSST_SPHGEOM_ELLIPSE_H_