quaternion.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_BASIC_QUATERNION
#define GEOGRAM_BASIC_QUATERNION
 
#include <geogram/basic/common.h>
#include <geogram/basic/geometry.h>
#include <iostream>
 
 
namespace GEO {
 
    class GEOGRAM_API Quaternion {
    public:
 
    Quaternion() : v_(0.0,0.0,0.0), s_(1.0) {
    }
 
    Quaternion(const Quaternion& rhs) : v_(rhs.v_), s_(rhs.s_) {
    }
 
    Quaternion(
        double x, double y, double z, double w
    ) : v_(x,y,z), s_(w) {
    }
 
    Quaternion( const vec3& v, double s ) : v_(v), s_(s) {
    }
 
    Quaternion& operator = ( const Quaternion &q ) {
        v_ = q.v_ ;
        s_ = q.s_ ;
        return *this ;
    }
 
    void set( const vec3& v, double s ) {
        v_ = v;
        s_ = s;
    }
 
    void print( std::ostream& out ) const {
        out << v_.x << " " << v_.y << " " << v_.z << " " << s_ ;
    }
 
 
    mat4 to_matrix() const;
 
    void  set_angle( double f ) {
        vec3 ax = axis();
        s_ = ::cos(f / 2.0);
        v_ = ax * ::sin(f / 2.0);
    }
 
    void scale_angle( double f ) {
        set_angle( f * angle() );
    }
 
    double angle() const {
        return 2.0 * acos( s_ ) ;
    }
 
    vec3 axis() const;
 
    static Quaternion spherical_interpolation(
        const Quaternion& from, const Quaternion& to,
        double t
    );
 
    const vec3& v() const {
        return v_;
    }
 
    double s() const {
        return s_;
    }
 
    private:
    vec3 v_ ;
    double s_ ;
    } ;
 
 
    /*************************************************************************/
 
    inline std::ostream& operator<<(std::ostream& out, const Quaternion& q) {
        q.print(out) ;
        return out ;
    }
 
 
    inline std::istream& operator>>(std::istream& in, Quaternion& q) {
        double x=0.0,y=0.0,z=0.0,w=0.0 ;
        in >> x >> y >> z >> w ;
        q.set(vec3(x,y,z),w) ;
        return in ;
    }
 
 
    inline Quaternion operator + (const Quaternion& a, const Quaternion& b) {
        return Quaternion(
            a.v() + b.v(),
            a.s() + b.s()
        ) ;
    }
 
    inline Quaternion operator - (const Quaternion& a, const Quaternion& b) {
        return Quaternion(
            a.v() - b.v(),
            a.s() - b.s()
        ) ;
    }
 
    inline Quaternion operator - (const Quaternion& a ) {
        return Quaternion( -1.0 * a.v(), -a.s() );
    }
 
    inline Quaternion operator * ( const Quaternion& a, const Quaternion& b) {
        return Quaternion(
            a.s() * b.v() + b.s() * a.v() + cross(a.v(),b.v()),
            a.s() * b.s() - dot(a.v() , b.v())
        );
    }
 
    inline Quaternion operator * ( const Quaternion& a, double t ) {
        return Quaternion( t * a.v(), a.s() * t );
    }
 
 
    inline Quaternion operator * ( double t, const Quaternion& a ) {
        return Quaternion( t * a.v(), a.s() * t );
    }
 
}
 
#endif