Point.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef UTL_POINT_H
#define UTL_POINT_H
 
#include "Vec3.h"
 
 
namespace utl
{
  class Point : public Vec4
  {
    Real par[3]; 
 
  public:
    Point() : Vec4(par) { par[0] = par[1] = par[2] = Real(0); }
 
    explicit Point(const Vec3& X) : Vec4(X,Real(0),par)
    {
      par[0] = par[1] = par[2] = Real(0);
    }
 
    Point(const Vec3& X, const std::vector<Real>& U) : Vec4(X,Real(0),par)
    {
      for (size_t i = 0; i < 3; i++)
        par[i] = i < U.size() ? U[i] : 0.0;
    }
 
    Point(const Point& X) : Vec4(X,X.t,par)
    {
      for (size_t i = 0; i < 3; i++)
        par[i] = X.par[i];
    }
 
    explicit Point(const std::vector<Real>& X) : Vec4(X,par)
    {
      for (size_t i = 0; i < 3; i++)
        par[i] = 3+i < X.size() ? X[3+i] : 0.0;
    }
 
    Point& operator=(const Vec4& X)
    {
      x = X.x;
      y = X.y;
      z = X.z;
      t = X.t;
      idx = X.idx;
      if (X.u)
        for (size_t i = 0; i < 3; i++)
          par[i] = X.u[i];
 
      return *this;
    }
 
    Point& operator+=(const Vec4& X)
    {
      x += X.x;
      y += X.y;
      z += X.z;
      t += X.t;
      if (X.u)
        for (size_t i = 0; i < 3; i++)
          par[i] += X.u[i];
 
      return *this;
    }
 
    Point& operator*=(Real c)
    {
      x *= c;
      y *= c;
      z *= c;
      t *= c;
      for (size_t i = 0; i < 3; i++)
        par[i] *= c;
 
      return *this;
    }
 
    Point& operator/=(Real d) { return this->operator*=(Real(1)/d); }
  };
}
 
 
inline utl::Point operator*(const utl::Point& a, Real value)
{
  return utl::Point({ value*a.x   , value*a.y   , value*a.z,
                      value*a.u[0], value*a.u[1], value*a.u[2] });
}
 
 
inline utl::Point operator*(Real value, const utl::Point& a)
{
  return utl::Point({ value*a.x   , value*a.y   , value*a.z,
                      value*a.u[0], value*a.u[1], value*a.u[2] });
}
 
 
inline utl::Point operator+(const utl::Point& a, const utl::Point& b)
{
  return utl::Point({ a.x   +b.x   , a.y   +b.y   , a.z   +b.z,
                      a.u[0]+b.u[0], a.u[1]+b.u[1], a.u[2]+b.u[2] });
}
 
 
typedef std::vector<utl::Point> PointVec; 
 
#endif