glc_vector3d.h

Go to the documentation of this file.

/****************************************************************************

 This file is part of the GLC-lib library.
 Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
 http://glc-lib.sourceforge.net

 GLC-lib is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 3 of the License, or
 (at your option) any later version.

 GLC-lib 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 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with GLC-lib; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*****************************************************************************/


#ifndef GLC_VECTOR3D_H_
#define GLC_VECTOR3D_H_

#include <QDataStream>

#include "glc_utils_maths.h"
#include "glc_vector3df.h"
#include "glc_vector2d.h"
#include "../glc_config.h"




class GLC_LIB_EXPORT GLC_Vector3d
{
        friend class GLC_Vector4d;
        friend class GLC_Matrix4x4;

        inline friend GLC_Vector3d operator - (const GLC_Vector3d &Vect)
        {return GLC_Vector3d(-Vect.m_Vector[0], -Vect.m_Vector[1], -Vect.m_Vector[2]);}

        inline friend GLC_Vector3d operator*(double s, const GLC_Vector3d &v)
        {return GLC_Vector3d(s * v.m_Vector[0], s * v.m_Vector[1], s * v.m_Vector[2]);}



public:

        inline GLC_Vector3d();

        inline GLC_Vector3d(double x, double y, double z);

        inline GLC_Vector3d(const GLC_Vector3d &vector)
        {memcpy(m_Vector, vector.m_Vector, sizeof(double) * 3);}

        inline GLC_Vector3d(const GLC_Vector3df &vector);




public:
        inline double x() const
        {return m_Vector[0];}

        inline double y() const
        {return m_Vector[1];}

        inline double z() const
        {return m_Vector[2];}

        inline const double *data() const
        {return m_Vector;}

        inline bool isNull() const
        {return (m_Vector[0] == 0.0f) && (m_Vector[1] == 0.0f) && (m_Vector[2] == 0.0f);}

        inline double length() const
        {return sqrt(m_Vector[0] * m_Vector[0] + m_Vector[1] * m_Vector[1] + m_Vector[2] * m_Vector[2]);}


        inline GLC_Vector2d toVector2d(const GLC_Vector3d& mask) const;

        inline double angleWithVect(GLC_Vector3d Vect) const;

        inline GLC_Vector3df toVector3df() const
        {return GLC_Vector3df(static_cast<float>(m_Vector[0]), static_cast<float>(m_Vector[1]), static_cast<float>(m_Vector[2]));}

        inline QString toString() const;

        inline GLC_Vector3d inverted() const
        {return GLC_Vector3d(*this).invert();}




public:
        inline GLC_Vector3d operator + (const GLC_Vector3d &vector) const
        {return GLC_Vector3d(m_Vector[0] + vector.m_Vector[0], m_Vector[1] + vector.m_Vector[1], m_Vector[2] + vector.m_Vector[2]);}

        inline GLC_Vector3d& operator = (const GLC_Vector3d &vector)
        {
                if (this != &vector) memcpy(m_Vector, vector.m_Vector, sizeof(double) * 3);
                return *this;
        }

        inline GLC_Vector3d& operator = (const GLC_Vector3df &);

        inline GLC_Vector3d& operator += (const GLC_Vector3d &vector)
        {
                *this= *this + vector;
                return *this;
        }

        inline GLC_Vector3d operator - (const GLC_Vector3d &Vect) const
        {return GLC_Vector3d(m_Vector[0] - Vect.m_Vector[0], m_Vector[1] - Vect.m_Vector[1], m_Vector[2] - Vect.m_Vector[2]);}

        GLC_Vector3d& operator -= (const GLC_Vector3d &Vect)
        {
                *this= *this - Vect;
                return *this;
        }

        inline GLC_Vector3d operator ^ (const GLC_Vector3d &vector) const;

        inline double operator * (const GLC_Vector3d &Vect) const
        {return m_Vector[0] * Vect.m_Vector[0] + m_Vector[1] * Vect.m_Vector[1] + m_Vector[2] * Vect.m_Vector[2];}

        inline GLC_Vector3d operator * (double Scalaire) const
        {return GLC_Vector3d(m_Vector[0] * Scalaire, m_Vector[1] * Scalaire, m_Vector[2] * Scalaire);}


        inline bool operator == (const GLC_Vector3d &vector) const;

        inline bool operator > (const GLC_Vector3d &vector) const;

        inline bool operator < (const GLC_Vector3d &vector) const;

        inline bool operator != (const GLC_Vector3d &Vect) const
        {return !(*this == Vect);}




public:
        inline GLC_Vector3d& setX(const double &dX)
        {
                m_Vector[0]= dX;
                return *this;
        }

        inline GLC_Vector3d& setY(const double &dY)
        {
                m_Vector[1]= dY;
                return *this;
        }

        inline GLC_Vector3d& setZ(const double &dZ)
        {
                m_Vector[2]= dZ;
                return *this;
        }

        inline GLC_Vector3d& setVect(double, double, double);

        GLC_Vector3d& setVect(const GLC_Vector3d &vector)
        {
                memcpy(m_Vector, vector.m_Vector, sizeof(double) * 3);
                return *this;
        }

        inline GLC_Vector3d& setLength(double);

        inline GLC_Vector3d& normalize()
        {return setLength(1.0);}

        inline GLC_Vector3d& invert();



//Private attributes
private:
        double m_Vector[3];

}; //class GLC_Vector3d

// Vector constant in glc namespace
namespace glc
{
        // Axis definition
        const GLC_Vector3d X_AXIS(1.0, 0.0, 0.0);

        const GLC_Vector3d Y_AXIS(0.0, 1.0, 0.0);

        const GLC_Vector3d Z_AXIS(0.0, 0.0, 1.0);
};

typedef GLC_Vector3d GLC_Point3d;

inline QDataStream &operator<<(QDataStream & stream, const GLC_Vector3d & vector)
{
        stream << vector.x() << vector.y() << vector.z();
        return stream;
}

inline QDataStream &operator>>(QDataStream &stream, GLC_Vector3d &vector)
{
        double x, y, z;
        stream >> x >> y >> z;
        vector.setVect(x, y, z);
        return stream;
}

// inline method implementation

GLC_Vector3d::GLC_Vector3d()
{
        m_Vector[0]= 0.0;
        m_Vector[1]= 0.0;
        m_Vector[2]= 0.0;
}

GLC_Vector3d::GLC_Vector3d(double x, double y, double z)
{
        m_Vector[0]= x;
        m_Vector[1]= y;
        m_Vector[2]= z;
}

GLC_Vector3d::GLC_Vector3d(const GLC_Vector3df &vector)
{
        m_Vector[0]= static_cast<double>(vector.m_Vector[0]);
        m_Vector[1]= static_cast<double>(vector.m_Vector[1]);
        m_Vector[2]= static_cast<double>(vector.m_Vector[2]);
}

GLC_Vector3d& GLC_Vector3d::operator = (const GLC_Vector3df &Vect)
{
        m_Vector[0]= static_cast<double>(Vect.m_Vector[0]);
        m_Vector[1]= static_cast<double>(Vect.m_Vector[1]);
        m_Vector[2]= static_cast<double>(Vect.m_Vector[2]);

        return *this;
}

GLC_Vector3d GLC_Vector3d::operator ^ (const GLC_Vector3d &vector) const
{
        GLC_Vector3d vectResult;
        vectResult.m_Vector[0]= m_Vector[1] * vector.m_Vector[2] - m_Vector[2] * vector.m_Vector[1];
        vectResult.m_Vector[1]= m_Vector[2] * vector.m_Vector[0] - m_Vector[0] * vector.m_Vector[2];
        vectResult.m_Vector[2]= m_Vector[0] * vector.m_Vector[1] - m_Vector[1] * vector.m_Vector[0];

        return vectResult;
}

bool GLC_Vector3d::operator == (const GLC_Vector3d &vector) const
{
        bool bResult= qFuzzyCompare(m_Vector[0], vector.m_Vector[0]);
        bResult= bResult && qFuzzyCompare(m_Vector[1], vector.m_Vector[1]);
        bResult= bResult && qFuzzyCompare(m_Vector[2], vector.m_Vector[2]);

        return bResult;
}

bool GLC_Vector3d::operator > (const GLC_Vector3d &vector) const
{
        bool result= m_Vector[0] > vector.m_Vector[0];
        result= result && (m_Vector[1] > vector.m_Vector[1]);
        result= result && (m_Vector[2] > vector.m_Vector[2]);
        return result;
}

bool GLC_Vector3d::operator < (const GLC_Vector3d &vector) const
{
        bool result= m_Vector[0] < vector.m_Vector[0];
        result= result && (m_Vector[1] < vector.m_Vector[1]);
        result= result && (m_Vector[2] < vector.m_Vector[2]);
        return result;
}

GLC_Vector3d& GLC_Vector3d::setVect(double x, double y, double z)
{
        m_Vector[0]= x;
        m_Vector[1]= y;
        m_Vector[2]= z;

        return *this;
}

inline GLC_Vector3d& GLC_Vector3d::setLength(double norme)
{
        const double normCur= sqrt( m_Vector[0] * m_Vector[0] + m_Vector[1] * m_Vector[1] + m_Vector[2] * m_Vector[2]);

        if (normCur != 0.0f)
        {
                const double Coef = norme / normCur;

                m_Vector[0] = m_Vector[0] * Coef;
                m_Vector[1] = m_Vector[1] * Coef;
                m_Vector[2] = m_Vector[2] * Coef;
        }
        return *this;
}

GLC_Vector3d& GLC_Vector3d::invert()
{
        m_Vector[0]= - m_Vector[0];
        m_Vector[1]= - m_Vector[1];
        m_Vector[2]= - m_Vector[2];
        return *this;
}

GLC_Vector2d GLC_Vector3d::toVector2d(const GLC_Vector3d& mask) const
{
        GLC_Vector2d resultVect;
        if (mask.m_Vector[0] == 0.0)
        {
                resultVect.setX(m_Vector[0]);
                if (mask.m_Vector[1] == 0.0) resultVect.setY(m_Vector[1]);
                else resultVect.setY(m_Vector[2]);
        }
        else resultVect.setVect(m_Vector[1], m_Vector[2]);

        return resultVect;
}

double GLC_Vector3d::angleWithVect(GLC_Vector3d Vect) const
{
        GLC_Vector3d ThisVect(*this);
        ThisVect.normalize();
        Vect.normalize();
        // Rotation axis
        const GLC_Vector3d VectAxeRot(ThisVect ^ Vect);
        // Check if the rotation axis vector is null
        if (!VectAxeRot.isNull())
        {
                return acos(ThisVect * Vect);
        }
        else return 0.0;
}

QString GLC_Vector3d::toString() const
{
        QString result("[");

        result+= QString::number(m_Vector[0]) + QString(" , ");
        result+= QString::number(m_Vector[1]) + QString(" , ");
        result+= QString::number(m_Vector[2]) + QString("]");

        return result;
}

#endif /*GLC_VECTOR3D_H_*/