Point3D.h

Go to the documentation of this file.

#ifndef POINT3D_H_
#define POINT3D_H_

#include <cmath>

#include <ostream>
using std::ostream;

#include <boost/tuple/tuple.hpp>
#include <boost/functional/hash.hpp>
using boost::hash;
using boost::hash_combine;

template<class T>
class Point3D
{
public:
    Point3D(T x, T y, T z) :
            _x(x), _y(y), _z(z)
    {}
    ;

    Point3D()
            : _x(T()), _y(T()), _z(T())
    {}
    ;

    virtual ~Point3D()
    {}
    ;

    T x() const
    {
        return _x;
    }

    T y() const
    {
        return _y;
    }
    
    T z() const

    {
        return _z;
    }
    
    void x(const T &xc)
    {
      _x = xc;  
    }
    
    void y(const T &yc)
    {
      _y = yc;  
    }
    
    void z(const T &zc)
    {
      _z = zc;  
    }


    void set(T x, T y, T z)
    {
        _x = x;
        _y = y;
        _z = z;
    }

    T sqr_distance(const Point3D<T> &other) const
    {
        return operator-(other).sqr_abs();
    }

    double distance(const Point3D<T> &other) const
    {
        return operator-(other).abs();
    }


    T sqr_abs() const
    {
        return _x*_x + _y*_y + _z*_z;
    }

    double abs() const
    {
        return sqrt((double)sqr_abs());
    }

    Point3D<T> operator+(const Point3D<T> &other) const
    {
        return Point3D<T>(_x + other._x,
                          _y + other._y,
                          _z + other._z);
    }

    Point3D<T> operator-(const Point3D<T> &other) const
    {
        return Point3D<T>(_x - other._x,
                          _y - other._y,
                          _z - other._z);
    }

    Point3D<T> &operator+=(const Point3D<T> &other)
    {
        _x += other._x;
        _y += other._y;
        _z += other._z;
        return *this;
    }

    Point3D<T> &operator-=(const Point3D<T> &other)
    {
        _x -= other._x;
        _y -= other._y;
        _z -= other._z;
        return *this;
    }

    bool operator==(const Point3D<T> &other) const
    {
        return (_x == other._x && _y == other._y && _z == other._z);
    };

    friend std::size_t hash_value(Point3D<T> const& p)
    {
        std::size_t seed = 0;
        boost::hash_combine(seed, p._x);
        boost::hash_combine(seed, p._y);
        boost::hash_combine(seed, p._z);
        return seed;
    }

    template<class U>
    friend ostream & operator<<( ostream & ss, const Point3D<U> & p);

protected:
    T _x;
    T _y;
    T _z;
};

template< typename T>
Point3D<T> operator-(const Point3D<T> & p)
{
    return Point3D<T>() - p;
}


template< typename T>
T sqr_distance(const Point3D<T> &p1, const Point3D<T> &p2)
{
    return (p1 - p2).sqr_abs();
}

template< typename T>
double distance(Point3D<T> &p1, Point3D<T> &p2)
{
    return (p1 - p2).abs();
}

template< typename T>
ostream & operator <<( ostream & ss, const Point3D<T> & p)
{
    return ss << "[" << p._x << ", " << p._y << ", " << p._z << "]";
}

template< typename T>
size_t hash_value( Point3D<double> const& p )
{
        size_t seed = 0;
        hash_combine( seed, p.x());
        hash_combine( seed, p.y());
        hash_combine( seed, p.z());
        return seed;
}

typedef Point3D<double> Point3Dd;

typedef Point3D<float> Point3Df;

typedef Point3D<int> GridPoint3D;

namespace instantiate {
        inline int instantiate() {
                int m = sizeof( Point3D<int> );
                int n = m + sizeof( GridPoint3D );
                Point3D<int> a;
                GridPoint3D b;
                distance( a, b);
                sqr_distance(a, b);
                GridPoint3D c = -b;
                Point3D<double> d(1,2,3);
                Point3Dd dd(1,2,3);
                Point3D<float> f(1,2,3);
                return n;               
        }
}


class Volume3DSize
{
public:

    typedef enum { X = 0, Y = 1, Z = 2 } Coordinate;

    explicit Volume3DSize(size_t x = 1, size_t y = 1, size_t z = 1)
            : _x(x), _y(y), _z(z)
    {
    }

    size_t operator[] ( int idx) const
    {
        switch(idx) {
        case X:
            return _x;
        case Y:
            return _y;
        case Z:
            return _z;
        }
        return 0;
    }

    size_t x() const
    {
        return _x;
    }

    size_t y() const
    {
        return _y;
    }


    size_t z() const
    {
        return _z;
    }
    
    size_t numPoints() const
    {
        return _x * _y * _z;    
    }

protected:
    size_t _x;
    size_t _y;
    size_t _z;
};


#endif /*Point3D_H_*/

---