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_decl(StandardException) {
        ecl_assert_throw( index<N, StandardException(LOC,OutOfRangeError));
        return elements[index];
    }

        const T& operator [](const unsigned int& index) const ecl_assert_throw_decl(StandardException) {
        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_decl(StandardException) {
        ecl_assert_throw( index<2, StandardException(LOC,OutOfRangeError));
        return elements[index];
    }

        const T  operator [](const unsigned int& index) const ecl_assert_throw_decl(StandardException) {
        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_ */