Point2D.h

Go to the documentation of this file.

#ifndef POINT2D_H_
#define POINT2D_H_

#include "Point3D.h"

#include <cmath>

#include <ostream>
using std::ostream;
using std::cout;

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

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

    Point2D(const Point2D<T> &other)
    : _x(other.x()), _y(other.y())
    {
    }

    Point2D(const Point3D<T> &other)
    : _x(other.x()), _y(other.y())
    {
    }

    Point2D()
    : _x(T()), _y(T())
    {}
    

    virtual ~Point2D()
    {}
    
    
    T x() const
    {
        return _x;
    }

    T y() const
    {
        return _y;
    }
        
    void x(const T &xc)
    {
      _x = xc;  
    }
    
    void y(const T &yc)
    {
      _y = yc;  
    }
    
    void set(T x, T y)
    {
        _x = x;
        _y = y;
    }

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

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

    void rotate(double theta)
    {
        double new_x = cos(theta)*_x + sin(theta)*_y;
        _y = -sin(theta)*_x + cos(theta)*_y;

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

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

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

    Point2D<T> operator*(const T scale) const
    {
        return Point2D<T>(_x * scale,
                          _y * scale);
    }

    Point2D<T> operator/(const T scale) const
    {
        return Point2D<T>(_x / scale,
                          _y / scale);
    }

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

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

    Point2D<T> &operator*=(const T scale)
    {
        _x *= scale;
        _y *= scale;
        return *this;
    }

    Point2D<T> &operator/=(const T scale)
    {
        _x /= scale;
        _y /= scale;
        return *this;
    }

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

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

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

protected:
    T _x;
    T _y;
};

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


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

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

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

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

typedef Point2D<double> Point2Dd;

typedef Point2D<float> Point2Df;

typedef Point2D<int> GridPoint2D;


class Volume2DSize
{
public:

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

    explicit Volume2DSize(size_t x = 1, size_t y = 1)
            : _x(x), _y(y)
    {
    }

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

    size_t x() const
    {
        return _x;
    }

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

protected:
    size_t _x;
    size_t _y;
};



#if !defined(max)
#define max(A, B) ((A) > (B) ? (A) : (B))
#endif
#if !defined(min)
#define min(A, B) ((A) < (B) ? (A) : (B))
#endif


template<class T>
class Point2DDistance 
{
public:
    Point2DDistance(bool toroid=true, T toroid_off=0,
                    int src_shape_x=1, int src_shape_y=1,
                    int dst_shape_x=1, int dst_shape_y=1,
                    double src_scale=1.0, double dst_scale=1.0,
                    Point2D<T> src_center=Point2D<T>(),
                    Point2D<T> dst_center=Point2D<T>())
        : _toroid(toroid)
        , _toroid_off(toroid_off)
        , _src_scale(src_scale)
        , _dst_scale(dst_scale)
        , _src_center(src_center)
        , _dst_center(dst_center)
        , _src_shape_x(src_shape_x)
        , _src_shape_y(src_shape_y)
        , _dst_shape_x(dst_shape_x)
        , _dst_shape_y(dst_shape_y)
    {
        //x in centered coordinates
        _min_sx = (T)(_src_scale * (-(T)(_src_shape_x - 1) / 2 ) - _toroid_off);
        _max_sx = (T)(_src_scale * ((T)(_src_shape_x - 1) / 2 ));
        _min_dx = (T)(_dst_scale * (-(T)(_dst_shape_x - 1) / 2) - _toroid_off);
        _max_dx = (T)(_dst_scale * ((T)(_dst_shape_x - 1) / 2));

        //y
        _min_sy = (T)(_src_scale * (-(T)(_src_shape_y - 1) / 2) - _toroid_off);
        _max_sy = (T)(_src_scale * ((T)(_src_shape_y - 1) / 2));
        _min_dy = (T)(_dst_scale * (-(T)(_dst_shape_y - 1) / 2) - _toroid_off);
        _max_dy = (T)(_dst_scale * ((T)(_dst_shape_y - 1) / 2));
    }

    
    T sqr_distance(const Point2D<T> &src, const Point2D<T> &dst) const
    {
        Point2D<T> s = (src - _src_center)*_src_scale;
        Point2D<T> d = (dst - _dst_center)*_dst_scale;
        
        if (_toroid == false)
        {
            return s.sqr_distance(d);
        }
        else
        {               
            T d1 = fabs(d.x() - s.x());
            T d2 = fabs(_max_dx - d.x()) + fabs(_min_sx - s.x());
            T d3 = fabs(_max_sx - s.x()) + fabs(_min_dx - d.x());

            T dx = min(min(d1, d2), d3);

            d1 = fabs(d.y() - s.y());
            d2 = fabs(_max_dy - d.y()) + fabs(_min_sy - s.y());
            d3 = fabs(_max_sy - s.y()) + fabs(_min_dy - d.y());

            T dy = min(min(d1, d2), d3);

            return dx*dx + dy*dy;
        }
    }


    Point2D<T> diff(const Point2D<T> &src, const Point2D<T> &dst) const
    {
        Point2D<T> s = (src - _src_center)*_src_scale;
        Point2D<T> d = (dst - _dst_center)*_dst_scale;

        if(_toroid == false)
        {
             return Point2D<T>(s-d);
        }
        else
        {
             T d1 = fabs(d.x() - s.x());
             T d2 = fabs(_max_dx - d.x()) + fabs(_min_sx - s.x());
             T d3 = fabs(_max_sx - s.x()) + fabs(_min_dx - d.x());
             
             T dx = min(min(d1, d2), d3);
             
             d1 = fabs(d.y() - s.y());
             d2 = fabs(_max_dy - d.y()) + fabs(_min_sy - s.y());
             d3 = fabs(_max_sy - s.y()) + fabs(_min_dy - d.y());
             
             T dy = min(min(d1, d2), d3);

             return Point2D<T>(dx, dy);
        }
    }

    T distance(Point2D<T> &src, Point2D<T> &dst) const
    {
        return sqrt(sqr_distance(src, dst));
    }

//protected:
public:
    bool _toroid;
    T _toroid_off;

    double _src_scale;
    double _dst_scale;

    Point2D<T> _src_center;
    Point2D<T> _dst_center;

    int _src_shape_x;
    int _src_shape_y;
    int _dst_shape_x;
    int _dst_shape_y;

    T _min_dx, _min_dy, _max_dx, _max_dy;
    T _min_sx, _min_sy, _max_sx, _max_sy;    
};


namespace instantiate2d {
        inline int instantiate() {
                int m = sizeof( Point2D<int> );
                int n = m + sizeof( GridPoint2D );
                Point2D<int> a;
                GridPoint2D b;
                distance( a, b);
                sqr_distance(a, b);
                GridPoint2D c = -b;
        Point2D<double> d(1,2);
        Point2Dd dd(1.,2.);
        Point2D<float> f(1,2);
        Point2DDistance<double> pdistd; 
        Point2DDistance<float> pdistf; 
        Point2DDistance<int> pdisti; 
                return n;               
        }
}

#endif /*Point2D_H_*/

---