Point2D.hpp

Go to the documentation of this file.

//
// Point2D.hpp
// A 2-dimensional point (float)
//


#ifndef POINT2D_HPP
#define POINT2D_HPP

#include <cassert>
#include <iosfwd> // for istream, ostream
#include <ios>
#include <utility> // for std::pair<T,T>
#include <vector>
#include "../tools/MathToolbox.hpp"
#include "../tools/toolbox.hpp"
#include "../BasicDatatypes.hpp"


namespace datatypes
{
        

//
//This class defines a point in the two-dimensional plane.
//
class Point2D : public BasicData
{
public:
        typedef double value_type;

        typedef value_type floatingpoint_type;

private:
        value_type m_x;
        value_type m_y;
public:
        Point2D()
                : m_x(0)
                , m_y(0)
        { m_datatype = Datatype_Point2D; }

        Point2D(value_type x, value_type y)
                : m_x(x)
                , m_y(y)
        { m_datatype = Datatype_Point2D; }

//      Point2D(const ScanPoint& p);

//      explicit Point2D(const Point3D& p);

        // Estimate the memory usage of this object
        inline virtual const UINT32 getUsedMemory() const {return sizeof(*this);};

        //\{

        bool isZero() const;

        value_type getX() const { return m_x; }

        value_type getY() const { return m_y; }

        value_type dist() const;

        value_type getDist() const { return dist(); }

        value_type length() const { return dist(); }

        value_type angle() const;

        value_type getAngle() const { return angle(); }

        void toPolar(value_type& dist, value_type& angle) const;

        std::pair<value_type, value_type> toPolar() const;

        Point2D normalized() const;

        Point2D rotated(value_type angle_rad) const;

//      Point3D toPoint3D() const;

        //\}

        //\{

        void setX(value_type x) { m_x = x; }

        void setY(value_type y) { m_y = y; }

        void setXY(value_type x, value_type y) { m_x = x; m_y = y; }

        void normalize();

        void rotate(value_type angle);

        void setPolar(value_type dist, value_type angle);

        Point2D & operator*= ( value_type factor );

        Point2D & operator+= ( const Point2D & point );

        Point2D & operator-= ( const Point2D & point );

        Point2D & operator/= ( value_type divisor );

        //\}


        //\{

        value_type dist( const Point2D & point ) const;

//      value_type dist( const ScanPoint & point ) const;

        value_type distSquare ( const Point2D & point ) const;

        value_type angle(const Point2D& point) const;

        //\}

        //\{


        std::istream& read (std::istream& is, UINT32 version);


        void read (const BYTE*& buf, UINT32 version);


        std::ostream& write (std::ostream& os, UINT32 version) const;


        void write (BYTE*& buf, UINT32 version) const;

        std::string toString(UINT16 digits = 2) const;

        //\}

        static Point2D fromPolar(value_type dist, value_type angle);

        friend inline bool operator==(const Point2D &, const Point2D &);
        friend inline bool operator!=(const Point2D &, const Point2D &);
        friend inline const Point2D operator+(const Point2D &, const Point2D &);
        friend inline const Point2D operator-(const Point2D &, const Point2D &);
        friend inline const Point2D operator*(value_type, const Point2D &);
        friend inline const Point2D operator*(const Point2D &, value_type);
        friend inline Point2D::value_type operator*(const Point2D &p1, const Point2D &p2);
        friend inline const Point2D operator-(const Point2D &);
        friend inline const Point2D operator/(const Point2D &, value_type);
};

// Text output for debugging
std::ostream& operator<<(std::ostream& os, const Point2D& point);

// Inline functions

inline void Point2D::setPolar(value_type r, value_type angle)
{
        m_x = r * std::cos(angle);
        m_y = r * std::sin(angle);
}

inline Point2D & Point2D::operator*= ( value_type factor )
{
        m_x *= factor;
        m_y *= factor;
        return *this;
}

inline Point2D & Point2D::operator+= ( const Point2D & point )
{
        m_x += point.m_x;
        m_y += point.m_y;
        return *this;
}

inline Point2D & Point2D::operator-= ( const Point2D & point )
{
        m_x -= point.m_x;
        m_y -= point.m_y;
        return *this;
}

inline Point2D & Point2D::operator/= ( value_type divisor )
{
        assert(!fuzzyCompare(divisor, value_type(0.0)));
        m_x /= divisor;
        m_y /= divisor;
        return *this;
}

inline bool Point2D::isZero() const
{
        return (fuzzyCompare(m_x, value_type(0.0)) && fuzzyCompare(m_y, value_type(0.0)));
}

// Inline operators

inline bool operator==(const Point2D &p1, const Point2D &p2)
{
        return (fuzzyCompare(p1.m_x, p2.m_x)
                        || (isNaN(p1.m_x) && isNaN(p2.m_x)))
                   && (fuzzyCompare(p1.m_y, p2.m_y)
                           || (isNaN(p1.m_y) && isNaN(p2.m_y)));
}

inline bool operator!=(const Point2D &p1, const Point2D &p2)
{
        return ! operator==(p1, p2);
}

inline const Point2D operator+(const Point2D &p1, const Point2D &p2)
{
        return Point2D(p1.m_x + p2.m_x, p1.m_y + p2.m_y);
}

inline const Point2D operator-(const Point2D &p1, const Point2D &p2)
{
        return Point2D(p1.m_x - p2.m_x, p1.m_y - p2.m_y);
}

inline const Point2D operator*(const Point2D &p, Point2D::value_type factor)
{
        return Point2D(p.m_x * factor, p.m_y * factor);
}

inline const Point2D operator*(Point2D::value_type factor, const Point2D &p)
{
        return Point2D(p.m_x * factor, p.m_y * factor);
}

inline Point2D::value_type operator*(const Point2D &p1, const Point2D &p2)
{
        return p1.m_x * p2.m_x + p1.m_y * p2.m_y;
}

inline const Point2D operator-(const Point2D &p)
{
        return Point2D(-p.m_x, -p.m_y);
}

inline const Point2D operator/(const Point2D &p, Point2D::value_type divisor)
{
        assert(!fuzzyCompare(divisor, Point2D::value_type(0.0)));
        return Point2D(p.m_x / divisor, p.m_y / divisor);
}


inline Point2D::value_type Point2D::dist() const
{
        return hypot(m_x, m_y);
}

inline Point2D::value_type Point2D::angle() const
{
        return atan2(m_y, m_x);
}

inline Point2D::value_type Point2D::angle(const Point2D& point) const
{
        const double divisor(dist() * point.dist());
        assert(!fuzzyCompare(divisor, 0.0));

        return acos( (*this * point) / divisor );
}

inline void Point2D::toPolar(Point2D::value_type& r, Point2D::value_type& psi) const
{
        r = dist();
        psi = angle();
}

inline std::pair<Point2D::value_type, Point2D::value_type> Point2D::toPolar() const
{
        return std::make_pair(dist(), angle());
}

}       // namespace datatypes

#endif