Common/Geom/PointAlg.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_POINTALG_H
#define VOLUMILL_POINTALG_H

#include <Geom/Points.h>

namespace geom
{

inline
Vec3d crossProduct(const Vec3d &v0, const Vec3d &v1)
{
   return Vec3d(v0[1] * v1[2] - v0[2] * v1[1],
                v0[2] * v1[0] - v0[0] * v1[2],
                v0[0] * v1[1] - v0[1] * v1[0]);
}

inline
Point3d crossProduct(const Point3d &v0, const Point3d &v1)
{
   return Point3d(v0[1] * v1[2] - v0[2] * v1[1],
                v0[2] * v1[0] - v0[0] * v1[2],
                v0[0] * v1[1] - v0[1] * v1[0]);
}

template <class V>
inline
double tripleProduct(const V &v0, const V &v1, const V &v2)
{
   BOOST_STATIC_ASSERT(V::Dim == 3);
   return v0[0] * (v1[1] * v2[2] - v1[2] * v2[1])
        + v0[1] * (v1[2] * v2[0] - v1[0] * v2[2])
        + v0[2] * (v1[0] * v2[1] - v1[1] * v2[0])
        ;
}

inline
double crossProduct(const Vec2d &v0, const Vec2d &v1)
{
   return v0[0] * v1[1] - v0[1] * v1[0];
}

inline
double crossProduct(const Point2d &v0, const Point2d &v1)
{
   return v0[0] * v1[1] - v0[1] * v1[0];
}

template <int n>
VecNd<n> normalize(const VecNd<n> &v)
{
   double dot = v*v;
   if(dot <= 0.0)
   {
      // Really, we ought to throw an exception
      return VecNd<n>();
   }
   return v * (1.0/sqrt(dot));
}

template <int n>
inline
double length(const VecNd<n> &v)
{
   double dot = v*v;
   return sqrt(dot);
}

inline double
angle(const Vec2d &v0, const Vec2d &v1)
{
   double cross = crossProduct(v0, v1);
   double dot = v0 * v1;
   double a = atan2(cross, dot);
   return a;
}

template <int n>
inline double distance (const PointNd<n>& p0, const PointNd<n>& p1)
{
   return length (VecNd<n> (p1-p0));
}

template <class Vec>
inline
Vec projectParallel(const Vec &v1,
                    const Vec &v2)
{
   return ((v1 * v2) / (v2 * v2)) * v2;
}

template <class Vec>
inline
Vec projectPerp(const Vec &v1, const Vec &v2)
{
   return v1 - projectParallel(v1, v2);
}

}
#endif

---