[an error occurred while processing this directive]

hugin_base/hugin_math/Vector3.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _HUGIN_MATH_VECTOR3_H_
#define _HUGIN_MATH_VECTOR3_H_


#include <iostream>


// small number below which we consider that it's zero
#define EPSILON  0.0000001


class Vector3
{
public:
        double  x, y, z;

public:
        
        Vector3(): x(0), y(0), z(0) {}
                
        Vector3(double a, double b, double c): x(a), y(b), z(c) {}

        Vector3(const Vector3& v) { x = v.x; y = v.y; z = v.z; }
        
        inline Vector3& operator= (const Vector3& v)
    {
                x = v.x;
                y = v.y;
                z = v.z;
                return *this;
    }

        void Set(double a, double b, double c);

        inline bool operator== (const Vector3& v) const
        {
                return (v.x==x && v.y==y && v.z==z);
        }

        inline bool operator!= (const Vector3& v ) const
        {
                return !(v == *this);
        }

        bool IsZero() const;

        bool IsNearlyZero() const;
        
        bool IsNearlyEqual(const Vector3& v) const;

    friend Vector3 operator*( double Scale, const Vector3 & v )
    {
        return Vector3( v.x * Scale, v.y * Scale, v.z * Scale );
    }

        inline Vector3 operator+( const Vector3& v ) const
        {
                return Vector3( x + v.x, y + v.y, z + v.z );
        }

        inline Vector3 operator-( const Vector3& v ) const
        {
                return Vector3( x - v.x, y - v.y, z - v.z );
        }

        inline Vector3 operator*( double Scale ) const
        {
                return Vector3( x * Scale, y * Scale, z * Scale );
        }

        Vector3 operator/( double Scale ) const;

        inline Vector3 operator-() const
        {
                return Vector3( -x, -y, -z );
        }

        inline Vector3 operator+=( const Vector3& v )
        {
                x += v.x;
                y += v.y;
                z += v.z;
                return *this;
        }

        inline Vector3 operator-=( const Vector3& v )
        {
                x -= v.x;
                y -= v.y;
                z -= v.z;
                return *this;
        }

        inline Vector3 operator*=( double Scale )
        {
                x *= Scale;
                y *= Scale;
                z *= Scale;
                return *this;
        }

        Vector3 operator/=( double Scale );

        double Norm() const;
    
        double NormSquared() const;

        inline Vector3 Cross( const Vector3& v ) const
        {
                return Vector3( v.z*y - v.y*z, v.x*z - v.z*x, v.y*x - v.x*y);
        }

        inline double Dot( const Vector3& v ) const
        {
                return x*v.x + y*v.y + z*v.z;
        }

        bool Normalize();
        
        Vector3 GetNormalized() const;
};


inline std::ostream & operator<<(std::ostream & s, const Vector3 & v)
{
    s << "[ " << v.x << ", " << v.y << ", " << v.z << " ]";
    return s;
}

#endif // _H

---