cartesian_point.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef ECL_GEOMETRY_CARTESIAN_POINT_HPP_
#define ECL_GEOMETRY_CARTESIAN_POINT_HPP_
 
/*****************************************************************************
** Includes
*****************************************************************************/
 
#include <ecl/config/macros.hpp>
#include <ecl/exceptions/standard_exception.hpp>
#include <ecl/linear_algebra.hpp>
#include <ecl/math.hpp>
 
/*****************************************************************************
** Namespaces
*****************************************************************************/
 
namespace ecl {
 
/*****************************************************************************
** Interface [CartesianPoint<T,N>]
*****************************************************************************/
template <typename T, unsigned int N>
class ECL_PUBLIC CartesianPoint {
public:
        CartesianPoint(const T &value = T()) : elements(ecl::linear_algebra::Matrix<T,N,1>::Constant(value)) {}
        CartesianPoint(const ecl::linear_algebra::Matrix<T,N,1> &point_vector) : elements(point_vector) {}
 
    /*********************
    ** Assignment
    **********************/
        ecl::linear_algebra::CommaInitializer< ecl::linear_algebra::Matrix<T,N,1> > operator<<(const T &value) {
                return elements.operator<<(value);
    }
 
        T& operator [](const unsigned int& index) {
        ecl_assert_throw( index<N, StandardException(LOC,OutOfRangeError));
        return elements[index];
    }
 
        const T& operator [](const unsigned int& index) const {
        ecl_assert_throw( index<N, StandardException(LOC,OutOfRangeError));
        return elements[index];
    }
 
 
 
 
        ecl::linear_algebra::Matrix<T,N,1>& positionVector() { return elements; }
        const ecl::linear_algebra::Matrix<T,N,1>& positionVector() const { return elements; }
 
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
private:
        ecl::linear_algebra::Matrix<T,N,1> elements;
};
 
/*****************************************************************************
** Interface [CartesianPoint<T,3>]
*****************************************************************************/
template<typename T>
class ECL_PUBLIC CartesianPoint<T,3> {
public:
        CartesianPoint(const T &value = T()) : elements(ecl::linear_algebra::Matrix<T,3,1>::Constant(value)) {}
        CartesianPoint(const ecl::linear_algebra::Matrix<T,3,1> &vec) : elements(vec) {}
        CartesianPoint(const T &x_i, const T &y_i, const T &z_i) {
                elements << x_i, y_i, z_i;
        }
 
        virtual ~CartesianPoint() {}
 
    /*********************
    ** Assignment
    **********************/
        ecl::linear_algebra::CommaInitializer< ecl::linear_algebra::Matrix<T,3,1> > operator<<(const T &value) {
                return elements.operator<<(value);
    }
 
        ecl::linear_algebra::Matrix<T,3,1>& positionVector() { return elements; }
 
        const ecl::linear_algebra::Matrix<T,3,1>& positionVector() const { return elements; }
 
        unsigned int size() { return 3; }
 
        const T& x() const { return elements[0]; }
        const T& y() const { return elements[1]; }
        const T& z() const { return elements[2]; }
        T x() { return elements[0]; }
        T y() { return elements[1]; }
        T z() { return elements[2]; }
 
        void x(const T& value) { elements[0] = value; } 
        void y(const T& value) { elements[1] = value; } 
        void z(const T& value) { elements[2] = value; } 
        template <typename OutputStream, typename Type>
        friend OutputStream& operator<<(OutputStream &ostream , const CartesianPoint<Type,3> &point);
 
private:
        ecl::linear_algebra::Matrix<T,3,1> elements;
};
 
typedef CartesianPoint<double,3> CartesianPoint3d;  
typedef CartesianPoint<float,3> CartesianPoint3f;  
typedef CartesianPoint<int,3> CartesianPoint3i;  
/*********************
** Streaming
**********************/
template <typename OutputStream, typename Type>
OutputStream& operator<<(OutputStream &ostream , const CartesianPoint<Type,3> &point) {
        ostream << "[ " << point.x() << " " << point.y() << " " << point.z() << " ]";
        return ostream;
}
 
/*****************************************************************************
** Interface [CartesianPoint<T,2>]
*****************************************************************************/
template<typename T>
class ECL_PUBLIC CartesianPoint<T,2> {
public:
        CartesianPoint(const T &value = T()) : elements(ecl::linear_algebra::Matrix<T,2,1>::Constant(value)) {}
        CartesianPoint(const ecl::linear_algebra::Matrix<T,2,1> &vec) : elements(vec) {}
        CartesianPoint(const CartesianPoint<T,2> &point ) : elements( point.positionVector() ) {}
 
        CartesianPoint(const T &x_i, const T &y_i) {
                elements << x_i, y_i;
        }
 
        virtual ~CartesianPoint() {}
 
    /*********************
    ** Assignment
    **********************/
        ecl::linear_algebra::CommaInitializer< ecl::linear_algebra::Matrix<T,2,1> > operator<<(const T &value) {
                return elements.operator<<(value);
    }
 
        T& operator [](const unsigned int& index) {
        ecl_assert_throw( index<2, StandardException(LOC,OutOfRangeError));
        return elements[index];
    }
 
        const T  operator [](const unsigned int& index) const {
        ecl_assert_throw( index<2, StandardException(LOC,OutOfRangeError));
        return elements[index];
    }
 
        const CartesianPoint<T,2> & operator = (const CartesianPoint<T,2> &v)
        {
                elements = v.positionVector();
                return *this;
        }
        ecl::linear_algebra::Matrix<T,2,1>& positionVector() { return elements; }
 
        const ecl::linear_algebra::Matrix<T,2,1>& positionVector() const { return elements; }
 
        unsigned int size() { return 2; }
 
        const T& x() const { return elements[0]; }
        const T& y() const { return elements[1]; }
        T x() { return elements[0]; }
        T y() { return elements[1]; }
 
        bool    operator == (const CartesianPoint<T,2> & other ) const
        {
                if( other.x() != x() || other.y() != y() ) return false;
                else return true;
        }
 
        bool    operator != (const CartesianPoint<T,2> & other ) const
        {
                if( other.x() != x() || other.y() != y() ) return true;
                else return false;
        }
 
        void rotate( const double & angle )
        {
                double c = cos(angle);
                double s = sin(angle);
                double tx = x()*c - y()*s;
                double ty = x()*s + y()*c;
 
                elements[0] = tx;
                elements[1] = ty;
        }
 
        double get_angle(void)
        {
                return atan2( y(), x() );
        }
 
        void operator += ( const  CartesianPoint<T,2> & other )
        {
                elements += other.positionVector();
        }
 
        T distance ( const CartesianPoint<T,2> & other )
        {
                ecl::linear_algebra::Matrix<T,2,1> temp_element = elements - other.positionVector();
                return static_cast<T>( sqrt( temp_element[0]*temp_element[0]+temp_element[1]*temp_element[1]) );
        }
 
        T Normalize(void)
        {
                T mag = ecl::EuclideanNorm()( x(), y() );
//              T mag = static_cast<T>(sqrt( x()*x()+y()*y() ));
                if ( mag == static_cast<T>(0) ) // make a unit vector in z-direction
                {
                        elements[0] = 1.0;
                        elements[1] = 0.0;
                } else
                {
                        elements[0] *= (1.0/mag);
                        elements[1] *= (1.0/mag);
                }
                return mag;
        }
 
        CartesianPoint<T,2> operator * (double d) const
        {
                return CartesianPoint<T,2>( elements*d );
        }
 
        CartesianPoint<T,2> operator + (const CartesianPoint<T,2> &v) const
        {
                return CartesianPoint<T,2>( x()+v.x(), y()+v.y() );
        }
 
        CartesianPoint<T,2> operator - (const CartesianPoint<T,2> &v) const
        {
                return CartesianPoint<T,2>( x()-v.x(), y()-v.y() );
        }
 
        double Norm(void)
        {
                return static_cast<double>( ecl::EuclideanNorm()( x(), y() )  );
//              return (sqrt( x()*x()+y()*y() ));
        }
 
        void x(const T& value) { elements[0] = value; } 
        void y(const T& value) { elements[1] = value; } 
        template <typename OutputStream, typename Type>
        friend OutputStream& operator<<(OutputStream &ostream , const CartesianPoint<Type,2> &point);
 
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
private:
        ecl::linear_algebra::Matrix<T,2,1> elements;
};
 
typedef CartesianPoint<double,2> CartesianPoint2d;  
typedef CartesianPoint<float,2> CartesianPoint2f;  
typedef CartesianPoint<int,2> CartesianPoint2i;  
/*********************
** Streaming
**********************/
template <typename OutputStream, typename Type>
OutputStream& operator<<(OutputStream &ostream , const CartesianPoint<Type,2> &point) {
        ostream << "[ " << point.x() << " " << point.y() << " ]";
        return ostream;
}
 
}  // namespace ecl
 
#endif /* ECL_GEOMETRY_CARTESIAN_POINT_HPP_ */