vec.h

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

 Copyright (C) 2002-2008 Gilles Debunne. All rights reserved.

 This file is part of the QGLViewer library version 2.3.10.

 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>

#if QT_VERSION >= 0x040000
# include <QDomElement>
#else
# include <qdom.h>
#endif

// 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)
  double x, y, z;
#else
  union
  {
    struct { double x, y, z; };
    double v_[3];
  };
#endif

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

  Vec(double X, double Y, double 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(double X, double Y, double 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;
  // }

  double operator[](int i) const {
#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
    return (&x)[i];
#else
    return v_[i];
#endif
  }

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

  friend Vec operator*(double k, const Vec &a)
  {
    return a*k;
  }

  friend Vec operator/(const Vec &a, double 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 double epsilon = 1.0E-10f;
    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*=(double k)
  {
    x *= k; y *= k; z *= k;
    return *this;
  }

  Vec& operator/=(double 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 double 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

  double sqNorm() const { return x*x + y*y + z*z; }
#endif

  double squaredNorm() const { return x*x + y*y + z*z; }

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

  double normalize()
  {
    const double 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