vec.h

Go to the documentation of this file.

/****************************************************************************
 
 Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
 
 This file is part of the QGLViewer library version 2.6.3.
 
 http://www.libqglviewer.com - contact@libqglviewer.com
 
 This file may be used under the terms of the GNU General Public License 
 versions 2.0 or 3.0 as published by the Free Software Foundation and
 appearing in the LICENSE file included in the packaging of this file.
 In addition, as a special exception, Gilles Debunne gives you certain 
 additional rights, described in the file GPL_EXCEPTION in this package.
 
 libQGLViewer uses dual licensing. Commercial/proprietary software must
 purchase a libQGLViewer Commercial License.
 
 This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
*****************************************************************************/
 
#ifndef QGLVIEWER_VEC_H
#define QGLVIEWER_VEC_H
 
#include <math.h>
#include <iostream>
 
# include <QDomElement>
 
// Included by all files as vec.h is at the end of the include hierarchy
#include "config.h" // Specific configuration options.
 
namespace qglviewer {
 
class QGLVIEWER_EXPORT Vec
{
 
        // If your compiler complains the "The class "qglviewer::Vec" has no member "x"."
        // Add your architecture Q_OS_XXXX flag (see qglobal.h) in this list.
#if defined (Q_OS_IRIX) || defined (Q_OS_AIX) || defined (Q_OS_HPUX)
# define QGLVIEWER_UNION_NOT_SUPPORTED
#endif
 
public:
#if defined (DOXYGEN) || defined (QGLVIEWER_UNION_NOT_SUPPORTED)
        qreal x, y, z;
#else
        union
        {
                struct { qreal x, y, z; };
                qreal v_[3];
        };
#endif
 
        Vec() : x(0.0), y(0.0), z(0.0) {}
 
        Vec(qreal X, qreal Y, qreal Z) : x(X), y(Y), z(Z) {}
 
        template <class C>
        explicit Vec(const C& c) : x(c[0]), y(c[1]), z(c[2]) {}
        // Should NOT be explicit to prevent conflicts with operator<<.
 
        // ! Copy constructor
        // Vec(const Vec& v) : x(v.x), y(v.y), z(v.z) {}
 
        Vec& operator=(const Vec& v)
        {
                x = v.x;   y = v.y;   z = v.z;
                return *this;
        }
 
        void setValue(qreal X, qreal Y, qreal Z)
        { x=X; y=Y; z=Z; }
 
        // Universal equal operator which allows the use of any type in place of Vec,
        // as long as the [] operator is implemented (v[0]=v.x, v[1]=v.y, v[2]=v.z).
        // template <class C>
        // Vec& operator=(const C& c)
        // {
        // x=c[0]; y=c[1]; z=c[2];
        // return *this;
        // }
 
        qreal operator[](int i) const {
#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
                return (&x)[i];
#else
                return v_[i];
#endif
        }
 
        qreal& operator[](int i) {
#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
                return (&x)[i];
#else
                return v_[i];
#endif
        }
 
#ifndef DOXYGEN
 
        const double* address() const { qWarning("Vec::address() is deprecated, use operator const double* instead."); return operator const double*(); }
#endif
 
        operator const double*() const {
#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
                return &x;
#else
                return v_;
#endif
        }
 
        operator double*() {
#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
                return &x;
#else
                return v_;
#endif
        }
 
        operator const float*() const {
                static float* const result = new float[3];
                result[0] = (float)x;
                result[1] = (float)y;
                result[2] = (float)z;
                return result;
        }
 
        friend Vec operator+(const Vec &a, const Vec &b)
        {
                return Vec(a.x+b.x, a.y+b.y, a.z+b.z);
        }
 
        friend Vec operator-(const Vec &a, const Vec &b)
        {
                return Vec(a.x-b.x, a.y-b.y, a.z-b.z);
        }
 
        friend Vec operator-(const Vec &a)
        {
                return Vec(-a.x, -a.y, -a.z);
        }
 
        friend Vec operator*(const Vec &a, qreal k)
        {
                return Vec(a.x*k, a.y*k, a.z*k);
        }
 
        friend Vec operator*(qreal k, const Vec &a)
        {
                return a*k;
        }
 
        friend Vec operator/(const Vec &a, qreal k)
        {
#ifndef QT_NO_DEBUG
                if (fabs(k) < 1.0E-10)
                        qWarning("Vec::operator / : dividing by a null value (%f)", k);
#endif
                return Vec(a.x/k, a.y/k, a.z/k);
        }
 
        friend bool operator!=(const Vec &a, const Vec &b)
        {
                return !(a==b);
        }
 
        friend bool operator==(const Vec &a, const Vec &b)
        {
                const qreal epsilon = 1.0E-10;
                return (a-b).squaredNorm() < epsilon;
        }
 
        Vec& operator+=(const Vec &a)
        {
                x += a.x; y += a.y; z += a.z;
                return *this;
        }
 
        Vec& operator-=(const Vec &a)
        {
                x -= a.x; y -= a.y; z -= a.z;
                return *this;
        }
 
        Vec& operator*=(qreal k)
        {
                x *= k; y *= k; z *= k;
                return *this;
        }
 
        Vec& operator/=(qreal k)
        {
#ifndef QT_NO_DEBUG
                if (fabs(k)<1.0E-10)
                        qWarning("Vec::operator /= : dividing by a null value (%f)", k);
#endif
                x /= k; y /= k; z /= k;
                return *this;
        }
 
        friend qreal operator*(const Vec &a, const Vec &b)
        {
                return a.x*b.x + a.y*b.y + a.z*b.z;
        }
 
        friend Vec operator^(const Vec &a, const Vec &b)
        {
                return cross(a,b);
        }
 
        friend Vec cross(const Vec &a, const Vec &b)
        {
                return Vec(a.y*b.z - a.z*b.y,
                                   a.z*b.x - a.x*b.z,
                                   a.x*b.y - a.y*b.x);
        }
 
        Vec orthogonalVec() const;
 
#ifndef DOXYGEN
 
        qreal sqNorm() const { return x*x + y*y + z*z; }
#endif
 
        qreal squaredNorm() const { return x*x + y*y + z*z; }
 
        qreal norm() const { return sqrt(x*x + y*y + z*z); }
 
        qreal normalize()
        {
                const qreal n = norm();
#ifndef QT_NO_DEBUG
                if (n < 1.0E-10)
                        qWarning("Vec::normalize: normalizing a null vector (norm=%f)", n);
#endif
                *this /= n;
                return n;
        }
 
        Vec unit() const
        {
                Vec v = *this;
                v.normalize();
                return v;
        }
 
        void projectOnAxis(const Vec& direction);
        void projectOnPlane(const Vec& normal);
 
        explicit Vec(const QDomElement& element);
        QDomElement domElement(const QString& name, QDomDocument& document) const;
        void initFromDOMElement(const QDomElement& element);
 
#ifdef DOXYGEN
 
        std::ostream& operator<<(std::ostream& o, const qglviewer::Vec&);
#endif
};
 
} // namespace
 
std::ostream& operator<<(std::ostream& o, const qglviewer::Vec&);
 
#endif // QGLVIEWER_VEC_H