Common/Geom/Points.h

Go to the documentation of this file.

//-------------------------------------------------------------------
//  Copyright (c) 2004 Evan Sherbrooke and Michael Lauer
//
// This library 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 2.1 of the License, or (at your option) any later version.
//
// This library 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 this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//-------------------------------------------------------------------
#pragma once

#ifndef VOLUMILL_POINTS_H
#define VOLUMILL_POINTS_H
//
//
//
#include <cassert>
#include <boost/static_assert.hpp>

namespace geom
{

template <int n> class VecNd;

template <int n>
class PointNd
{
   friend class boost::serialization::access;
   template<class Archive>
   void serialize(Archive & ar, const unsigned int /*version*/)
   {
      ar & boost::serialization::make_nvp ("coord", m_coord);
   }
public:
   enum { Dim = n };
   typedef double Coord;

   // default copy ctor, dtor, op= all ok
   PointNd() { makeZero(); }
   // These ctors all complain if called with the wrong n
   inline PointNd(double a, double b);
   inline PointNd(double a, double b, double c);
   inline PointNd(double a, double b, double c, double d);
   inline explicit PointNd(const VecNd<n> &);

   double operator[] (int ii) const { return m_coord[ii]; }
   double &operator[] (int ii) { return m_coord[ii]; }

   inline PointNd<n> &operator+= (const VecNd<n> &);
   inline PointNd<n> &operator-= (const VecNd<n> &);

   // I'm leery of these, but they're useful for bezier stuff
   inline PointNd<n> &operator+= (const PointNd<n> &);
   inline PointNd<n> &operator-= (const PointNd<n> &);
   inline PointNd<n> &operator*= (double);
   inline PointNd<n> &operator/= (double);

   inline void makeZero()
   { for(int ii=0; ii<n; ii++) m_coord[ii] = 0; }
private:
   Coord m_coord[n];
};

template <int n>
class VecNd
{
   friend class boost::serialization::access;
   template<class Archive>
   void serialize(Archive & ar, const unsigned int /*version*/)
   {
      ar & boost::serialization::make_nvp ("coord", m_coord);
   }
public:
   enum { Dim = n };
   typedef double Coord;

   // default copy ctor, dtor, op= all ok
   VecNd() { makeZero(); }
   // These ctors all complain if called with the wrong n
   inline VecNd(double a, double b);
   inline VecNd(double a, double b, double c);
   inline VecNd(double a, double b, double c, double d);
   inline explicit VecNd(const PointNd<n> &);

   double operator[] (int ii) const { return m_coord[ii]; }
   double &operator[] (int ii) { return m_coord[ii]; }

   inline VecNd<n> &operator+= (const VecNd<n> &);
   inline VecNd<n> &operator-= (const VecNd<n> &);

   inline VecNd<n> &operator*= (double);
   inline VecNd<n> &operator/= (double);

   inline void makeZero()
   { for(int ii=0; ii<n; ii++) m_coord[ii] = 0; }

private:
   Coord m_coord[n];
};

template <int n>
PointNd<n>::PointNd(double a, double b)
{
   BOOST_STATIC_ASSERT(n == 2);
   m_coord[0] = a;
   m_coord[1] = b;
}

template <int n>
PointNd<n>::PointNd(double a, double b, double c)
{
   BOOST_STATIC_ASSERT(n == 3);
   m_coord[0] = a;
   m_coord[1] = b;
   m_coord[2] = c;
}

template <int n>
PointNd<n>::PointNd(double a, double b, double c, double d)
{
   BOOST_STATIC_ASSERT(n == 4);
   m_coord[0] = a;
   m_coord[1] = b;
   m_coord[2] = c;
   m_coord[3] = d;
}

template <int n>
PointNd<n>::PointNd(const VecNd<n> &v)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] = v[ii];
}

template <int n>
VecNd<n>::VecNd(double a, double b)
{
   BOOST_STATIC_ASSERT(n == 2);
   m_coord[0] = a;
   m_coord[1] = b;
}

template <int n>
VecNd<n>::VecNd(double a, double b, double c)
{
   BOOST_STATIC_ASSERT(n == 3);
   m_coord[0] = a;
   m_coord[1] = b;
   m_coord[2] = c;
}

template <int n>
VecNd<n>::VecNd(double a, double b, double c, double d)
{
   BOOST_STATIC_ASSERT(n == 4);
   m_coord[0] = a;
   m_coord[1] = b;
   m_coord[2] = c;
   m_coord[3] = d;
}

template <int n>
VecNd<n>::VecNd(const PointNd<n> &pt)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] = pt[ii];
}

template <int n>
PointNd<n> &PointNd<n>::operator+=(const VecNd<n> &vec)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] += vec[ii];
   return *this;
}

template <int n>
PointNd<n> &PointNd<n>::operator-=(const VecNd<n> &vec)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] -= vec[ii];
   return *this;
}

template <int n>
PointNd<n> &PointNd<n>::operator+=(const PointNd<n> &pt)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] += pt[ii];
   return *this;
}

template <int n>
PointNd<n> &PointNd<n>::operator-=(const PointNd<n> &pt)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] -= pt[ii];
   return *this;
}

template <int n>
PointNd<n> &PointNd<n>::operator*=(double scale)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] *= scale;
   return *this;
}

template <int n>
inline PointNd<n> &PointNd<n>::operator/= (double scale)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] /= scale;
   return *this;
}

template <int n>
VecNd<n> &VecNd<n>::operator+=(const VecNd<n> &vec)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] += vec[ii];
   return *this;
}

template <int n>
VecNd<n> &VecNd<n>::operator-=(const VecNd<n> &vec)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] -= vec[ii];
   return *this;
} 

template <int n>
VecNd<n> &VecNd<n>::operator*=(double scale)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] *= scale;
   return *this;
}

template <int n>
inline VecNd<n> &VecNd<n>::operator/= (double scale)
{
   for(int ii=0; ii<n; ii++)
      m_coord[ii] /= scale;
   return *this;
}

template <int n>
inline
PointNd<n> operator+(const PointNd<n> &pt, const VecNd<n> &vec)
{
   PointNd<n> ret(pt);
   return ret += vec;
}

template <int n>
inline
PointNd<n> operator-(const PointNd<n> &pt, const VecNd<n> &vec)
{
   PointNd<n> ret(pt);
   return ret -= vec;
}

template <int n>
inline
PointNd<n> operator+(const PointNd<n> &pt, const PointNd<n> &pt1)
{
   PointNd<n> ret(pt);
   return ret += pt1;
}

template <int n>
inline
PointNd<n> operator*(const PointNd<n> &pt, double scale)
{
   PointNd<n> ret(pt);
   ret *= scale;
   return ret;
}

template <int n>
inline
PointNd<n> operator/(const PointNd<n> &pt, double scale)
{
   PointNd<n> ret(pt);
   ret /= scale;
   return ret;
}

template <int n>
inline
PointNd<n> operator*(double scale, const PointNd<n> &pt)
{
   return pt * scale;
}

template <int n>
inline
VecNd<n> operator+(const VecNd<n> &vec0, const VecNd<n> &vec)
{
   VecNd<n> ret(vec0);
   return ret += vec;
}

template <int n>
inline
VecNd<n> operator-(const VecNd<n> &vec0, const VecNd<n> &vec)
{
   VecNd<n> ret(vec0);
   return ret -= vec;
}

template <int n>
inline
VecNd<n> operator*(const VecNd<n> &v, double scale)
{
   VecNd<n> ret(v);
   ret *= scale;
   return ret;
}

template <int n>
inline
VecNd<n> operator*(double scale, const VecNd<n> &v)
{
   VecNd<n> ret(v);
   ret *= scale;
   return ret;
}

template <int n>
inline
PointNd<n> operator-(const PointNd<n> &pt0, const PointNd<n> &pt1)
{
   PointNd<n> ret;
   for(int ii=0; ii<n; ii++)
      ret[ii] = pt0[ii]-pt1[ii];
   return ret;
}

template<int n>
inline
PointNd<n> operator-(const PointNd<n>& pt)
{
   PointNd<n> ret;
   for (int ii=0; ii<n; ++ii)
      ret[ii] = -pt[ii];
   return ret;
}

template <int n>
inline
double operator*(const VecNd<n> &vec0, const VecNd<n> &vec1)
{
   double ff = 0;
   for(int ii=0; ii<n; ii++)
      ff += vec0[ii] * vec1[ii];
   return ff;
}

template <int n>
inline
double operator*(const PointNd<n> &pt0, const PointNd<n> &pt1)
{
   double ff = 0;
   for(int ii=0; ii<n; ii++)
      ff += pt0[ii] * pt1[ii];
   return ff;
}

template <int n>
PointNd<n> linComb(double d0, 
                   const PointNd<n> &pt0,
                   double d1,
                   const PointNd<n> &pt1)
{
   PointNd<n> ret;
   for(int ii=0; ii<n; ii++)
      ret[ii] = d0*pt0[ii] + d1*pt1[ii];
   return ret;
}

template <int n>
VecNd<n> linComb(double d0, 
                 const VecNd<n> &pt0,
                 double d1,
                 const VecNd<n> &pt1)
{
   VecNd<n> ret;
   for(int ii=0; ii<n; ii++)
      ret[ii] = d0*pt0[ii] + d1*pt1[ii];
   return ret;
}

// Kinda yucky
template <int n>
bool operator==(const PointNd<n> &pt0, const PointNd<n> &pt1)
{
   for(int ii=0; ii<n; ii++)
   {
      if(pt0[ii] != pt1[ii])
         return false;
   }
   return true;
}

template <int n>
bool operator!=(const PointNd<n> &pt0, const PointNd<n> &pt1)
{
   return !(pt0 == pt1);
}

template <int n>
bool operator< (const PointNd<n> &pt0, const PointNd<n> &pt1)
{
   for (int ii=0; ii < n; ++ii)
   {
      if (pt0[ii] < pt1[ii])
         return true;
      else if (pt1[ii] < pt0[ii])
         return false;
   }
   return false;
}

typedef PointNd<2> Point2d;
typedef VecNd<2> Vec2d;
typedef PointNd<3> Point3d;
typedef VecNd<3> Vec3d;
typedef PointNd<4> Point4d;
typedef VecNd<4> Vec4d;

// Homogeneous conversions
template <int n>
inline
PointNd<n-1> projectHomogeneous(const PointNd<n> &pt)
{
   PointNd<n-1> ret;
   double denom = 1.0/pt[n-1];
   for(int ii=0; ii<n-1; ii++)
      ret[ii] = pt[ii]*denom;
   return ret;
}

template <int n>
inline
PointNd<n+1> makeHomogeneous(const PointNd<n> &pt, double weight = 1.0)
{
   PointNd<n+1> ret;
   for(int ii=0; ii<n; ii++)
      ret[ii] = pt[ii] * weight;
   ret[n] = weight;
   return ret;
}

//
// Specializations for efficiency
//
inline 
PointNd<3> operator+(const PointNd<3> &pt, const VecNd<3> &vec)
{
   return PointNd<3> (pt[0] + vec[0], pt[1] + vec[1], pt[2] + vec[2]);
}

inline 
PointNd<3> operator+(const PointNd<3> &pt, const PointNd<3> &pt1)
{
   return PointNd<3> (pt[0] + pt1[0], pt[1] + pt1[1], pt[2] + pt1[2]);
}

inline 
PointNd<3> operator-(const PointNd<3> &pt, const VecNd<3> &vec)
{
   return PointNd<3> (pt[0] - vec[0], pt[1] - vec[1], pt[2] - vec[2]);
}

inline 
PointNd<3> operator*(const PointNd<3> &pt, double scale)
{
   return PointNd<3> (pt[0] * scale, pt[1] * scale, pt[2] * scale);
}

inline 
PointNd<3> operator/(const PointNd<3> &pt, double scale)
{
   return PointNd<3> (pt[0] / scale, pt[1] / scale, pt[2] / scale);
}

}
#endif

---