vec.h

Go to the documentation of this file.

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

 This file is part of the QGLViewer library
 Copyright (C) 2002-2004  Gilles Debunne (Gilles.Debunne@imag.fr)
 Version 1.3.5 Release 8. Packaged on Monday December 22, 2003.

 http://www-imagis.imag.fr/Membres/Gilles.Debunne/CODE/QGLViewer

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

 libQGLViewer 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 General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with libQGLViewer; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

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

#ifndef QGLVIEWER_VEC_H
#define QGLVIEWER_VEC_H

#include <math.h>
#include <iostream>
#include <qdom.h>
#include "qapplication.h"

// Included by all files as vec.h is at the end of the include hierarchy
#include "config.h" // Specific (win32) configuration.

namespace qglviewer {

  class QGLVIEWER_EXPORT Vec
  {
  public:
    float x, y, z;


    explicit Vec() : x(0.0), y(0.0), z(0.0) {}

    explicit Vec(const float X, const float Y, const float Z) : x(X), y(Y), z(Z) {}


    template <class C>
    explicit Vec(const C& c) : x(c[0]), y(c[1]), z(c[2]) {}

    // explicit 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(const float X, const float Y, const float 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;
    // }
    

    float operator[](int i) const { return (&x)[i]; }

    float& operator[](int i) { return (&x)[i]; }

    const float* address() const { return &x; };

    operator const float*() const { return &x; };


    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, const float k)
    {
      return Vec(a.x*k, a.y*k, a.z*k);
    }

    friend Vec operator*(float k, const Vec &a)
    {
      return Vec(a.x*k, a.y*k, a.z*k);
    }

    friend Vec operator/(const Vec &a, const float k)
    {
#ifndef QT_NO_DEBUG
      if (fabs(k) < 1.0E-10)
    qWarning("Vec::operator / : dividing by a null value");
#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 float epsilon = 1.0E-10f;
      return (a-b).sqNorm() < 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*=(float k)
    {
      x *= k; y *= k; z *= k;
      return *this;
    }

    Vec& operator/=(float k)
    {
#ifndef QT_NO_DEBUG
      if (fabs(k)<1.0E-10)
    qWarning("Vec::operator /= : dividing by a null value");
#endif
      x /= k; y /= k; z /= k;
      return *this;
    }

    friend float operator*(const Vec &a, const Vec &b)
    {
      return a.x*b.x + a.y*b.y + a.z*b.z;
    }

    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);
    }

    friend Vec operator^(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);
    }


    float sqNorm() const { return x*x + y*y + z*z; }

    float norm() const { return sqrt(x*x + y*y + z*z); }

    Vec& normalize()
    {
      const float n = norm();
#ifndef QT_NO_DEBUG
      if (n < 1.0E-10)
    qWarning("Vec::normalize : normalizing a null vector");
#endif
      *this /= n;
      return *this;
    }
  
    void projectOnAxis(const Vec& dir);
    void projectOnPlane(const Vec& n);

    QDomElement domElement(const QString& name, QDomDocument& doc) const;
    void initFromDOMElement(const QDomElement& de);
  };
  
} // namespace

std::ostream& operator<<(std::ostream& o, const qglviewer::Vec&);
  
#endif // QGLVIEWER_VEC_H

---