UnitVector3d.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_UNITVECTOR3D_H_
#define LSST_SPHGEOM_UNITVECTOR3D_H_
 
 
#include "LonLat.h"
#include "Vector3d.h"
 
 
namespace lsst {
namespace sphgeom {
 
class UnitVector3d {
public:
    static UnitVector3d orthogonalTo(Vector3d const & v);
 
    static UnitVector3d orthogonalTo(Vector3d const & v1, Vector3d const & v2);
 
    static UnitVector3d northFrom(Vector3d const & v);
 
    static UnitVector3d orthogonalTo(NormalizedAngle const & a) {
        UnitVector3d u; u._v = Vector3d(-sin(a), cos(a), 0.0); return u;
    }
 
    static UnitVector3d fromNormalized(Vector3d const & v) {
        UnitVector3d u; u._v = v; return u;
    }
 
    static UnitVector3d fromNormalized(double x, double y, double z) {
        UnitVector3d u; u._v = Vector3d(x, y, z); return u;
    }
 
    static UnitVector3d X() {
        return UnitVector3d();
    }
 
    static UnitVector3d Y() {
        UnitVector3d u; u._v = Vector3d(0.0, 1.0, 0.0); return u;
    }
 
    static UnitVector3d Z() {
        UnitVector3d u; u._v = Vector3d(0.0, 0.0, 1.0); return u;
    }
 
    UnitVector3d() : _v(1.0, 0.0, 0.0) {}
 
    UnitVector3d(UnitVector3d const &v) = default;
 
    explicit UnitVector3d(Vector3d const & v) : _v(v) {
        _v.normalize();
    }
 
    UnitVector3d(double x, double y, double z) : _v(x, y, z) {
        _v.normalize();
    }
 
    explicit UnitVector3d(LonLat const & p) {
        *this = UnitVector3d(p.getLon(), p.getLat());
    }
 
    UnitVector3d(Angle lon, Angle lat);
 
    operator Vector3d const & () const { return _v; }
 
    bool operator==(Vector3d const & v) const { return _v == v; }
    bool operator!=(Vector3d const & v) const { return _v != v; }
 
    double const * getData() const { return _v.getData(); }
 
    double operator()(int i) const { return _v(i); }
 
    double x() const { return _v.x(); }
 
    double y() const { return _v.y(); }
 
    double z() const { return _v.z(); }
 
    double dot(Vector3d const & v) const { return _v.dot(v); }
 
    Vector3d cross(Vector3d const & v) const { return _v.cross(v); }
 
    Vector3d robustCross(UnitVector3d const & v) const {
        return (v + *this).cross(v - *this);
    }
 
    UnitVector3d operator-() const {
        UnitVector3d u; u._v = -_v; return u;
    }
 
    Vector3d operator*(double s) const { return _v * s; }
 
    Vector3d operator/(double s) const { return _v / s; }
 
    Vector3d operator+(Vector3d const & v) const { return _v + v; }
 
    Vector3d operator-(Vector3d const & v) const { return _v - v; }
 
    Vector3d cwiseProduct(Vector3d const & v) const {
        return _v.cwiseProduct(v);
    }
 
    UnitVector3d rotatedAround(UnitVector3d const & k, Angle a) const {
        return UnitVector3d(_v.rotatedAround(k, a));
    }
 
private:
    Vector3d _v;
};
 
 
std::ostream & operator<<(std::ostream &, UnitVector3d const &);
 
}} // namespace lsst::sphgeom
 
#endif // LSST_SPHGEOM_UNITVECTOR3D_H_