Subversion Repositories spk

#ifndef GEOMETRY_INCLUDED
#define GEOMETRY_INCLUDED

#include <math.h>

namespace geometry
{

template <class Ty>
class point3d
{
        public:
                typedef Ty value_type;
        
        public:
                Ty x, y, z;
                
                point3d()
                        : x(), y(), z()
                { }
                
                point3d(const Ty& x, const Ty& y, const Ty& z)
                        : x(x), y(y), z(z)
                { }
                
                double length() const
                {
                        return sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
                }
                
                bool isZero() const { return x==0 && x==0 && z==0; }
                
                bool operator == (const point3d& other) const
                {
                        return x==other.x && y==other.y && z==other.z;
                }
                
                bool operator != (const point3d& other) const { return !(*this==other); }
                
                point3d operator - (const value_type& b) const { return point3d(x - b, y - b, z - b); }
                point3d operator + (const value_type& b) const { return point3d(x + b, y + b, z + b); }
                
                point3d operator - (const point3d& b) const { return point3d(x - b.x, y - b.y, z - b.z); }
                point3d operator + (const point3d& b) const { return point3d(x + b.x, y + b.y, z + b.z); }
                
                point3d& operator -= (const value_type& b) { x -= b; y -= b; z -= b; return *this; }
                point3d& operator += (const value_type& b) { x += b; y += b; z += b; return *this; }
                
                point3d& operator -= (const point3d& b) { x -= b.x; y -= b.y; z -= b.z; return *this; }
                point3d& operator += (const point3d& b) { x += b.x; y += b.y; z += b.z; return *this; }
                
                bool operator > (double b) const { return length() > b; }
                bool operator < (double b) const { return length() < b; }
                
                bool operator > (const point3d& b) const { return length() > b.length(); }
                bool operator < (const point3d& b) const { return length() < b.length(); }
                
                point3d& operator /= (const value_type& v) { x/=v;      y/=v;   z/=v;   return *this;   }
                point3d& operator /= (const point3d& v) {       x/=v.x; y/=v.y; z/=v.z; return *this;   }
                
                point3d operator / (const value_type& v) const { return point3d(x / v, y / v, z / v); }
                point3d operator / (const point3d& v) const { return point3d(x / v.x, y / v.y, z / v.z); }
                
                point3d& operator *= (const value_type& v) { x*=v;      y*=v;   z*=v;   return *this;   }
                point3d& operator *= (const point3d& v) {       x*=v.x; y*=v.y; z*=v.z; return *this;   }
                
                point3d operator * (const value_type& v) const { return point3d(x * v, y * v, z * v); }
                point3d operator * (const point3d& v) const { return point3d(x * v.x, y * v.y, z * v.x); }
                
                point3d normalize() const { return *this / length(); }
                
                value_type dot(const point3d& b) const { return (x * b.x + y * b.y + z * b.z); }
                
                double angle(const point3d& b) const // in radians!
                {
                        return acos(normalize().dot(b.normalize()));
                }
                
                point3d cross(const point3d& b) const
                {
                        return point3d(y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x);
                }

};

template <class Ty>
class point2d
{
        public:
                typedef Ty value_type;
        
        public:
                Ty x, y;
                
                point2d()
                        : x(), y()
                { }
                
                point2d(const Ty& x, const Ty& y)
                        : x(x), y(y)
                { }
                
                double length() const { return sqrt(pow(x, 2) + pow(y, 2));     }
                
                bool operator == (const point2d& other) const   {       return x==other.x && y==other.y; }
                
                bool operator != (const point2d& other) const { return !(*this==other); }
                
                point2d operator - (const value_type& b) const { return point2d(x - b, y - b); }
                point2d operator + (const value_type& b) const { return point2d(x + b, y + b); }
                
                point2d operator - (const point2d& b) const { return point2d(x - b.x, y - b.y); }
                point2d operator + (const point2d& b) const { return point2d(x + b.x, y + b.y); }
                
                point2d& operator -= (const value_type& b) { x -= b; y -= b; return *this; }
                point2d& operator += (const value_type& b) { x += b; y += b; return *this; }
                
                point2d& operator -= (const point2d& b) { x -= b.x; y -= b.y; return *this; }
                point2d& operator += (const point2d& b) { x += b.x; y += b.y; return *this; }
                
                bool operator > (double b) const { return length() > b; }
                bool operator < (double b) const { return length() < b; }
                
                bool operator > (const point2d& b) const { return length() > b.length(); }
                bool operator < (const point2d& b) const { return length() < b.length(); }
                
                point2d& operator /= (const value_type& v) { x/=v;      y/=v;   return *this;   }
                point2d& operator /= (const point2d& v) {       x/=v.x; y/=v.y; return *this;   }
                
                point2d operator / (const value_type& v) const { return point2d(x / v, y / v); }
                point2d operator / (const point2d& v) const { return point2d(x / v.x, y / v.y); }
                
                point2d& operator *= (const value_type& v) { x*=v;      y*=v;   return *this;   }
                point2d& operator *= (const point2d& v) {       x*=v.x; y*=v.y; return *this;   }
                
                point2d operator * (const value_type& v) const { return point2d(x * v, y * v); }
                point2d operator * (const point2d& v) const { return point2d(x * v.x, y * v.y); }
                
                point2d normalize() const { return *this / length(); }
};

} // namespace geometry

#endif // !defined(GEOMETRY_INCLUDED)