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