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