Point3D.hpp

Go to the documentation of this file.

//
// Point3D.hpp
// A 3-dimensional cartesian point.
//
 
 
#ifndef POINT3D_HPP
#define POINT3D_HPP
 
#include <cassert>
#include <sstream>
#include <iosfwd> // for istream, ostream
#include <utility> // for std::pair<T,T>
#include "../BasicDatatypes.hpp"
#include "../tools/MathToolbox.hpp"             // for fuzzyCompare
 
namespace datatypes
{
        
class Point2D;
 
 
class Point3D : public BasicData
{
public:
        typedef double floatingpoint_type;
 
private:
        double m_x;
        double m_y;
        double m_z;
 
public:
        Point3D(double x, double y, double z)
                : m_x(x)
                , m_y(y)
                , m_z(z)
        {m_datatype = Datatype_Point3D;}
 
        Point3D()
                : m_x(0.0)
                , m_y(0.0)
                , m_z(0.0)
        {m_datatype = Datatype_Point3D;}
 
        explicit Point3D(const Point2D& p);
        
        // Estimate the memory usage of this object
        inline virtual const UINT32 getUsedMemory() const {return sizeof(*this);};
 
 
 
        //\{
 
        bool isZero() const;                            
        double getX() const { return m_x; }     
        double getY() const { return m_y; }     
        double getZ() const { return m_z; }     
 
        double length() const;                          
        double distFromOrigin() const;          
 
        double getAngleAroundX() const; 
        double getAngleAroundY() const; 
        double getAngleAroundZ() const; 
 
        Point2D toPoint2D() const;
        //\}
 
        //\{
 
        void setX(double x) { m_x = x; }        
        void setY(double y) { m_y = y; }        
        void setZ(double z) { m_z = z; }        
        void setXYZ(double x, double y, double z) { m_x = x; m_y = y; m_z = z; } 
 
        void rotateAroundX(double rollAngle);   
        void rotateAroundY(double pitchAngle);  
        void rotateAroundZ(double dYawAngle);   
 
        void normalize();       
 
        Point3D & operator+= ( const Point3D & point ); 
        Point3D & operator-= ( const Point3D & point ); 
        Point3D & operator/= ( double divisor );
        //\}
 
 
        //\{
        double dist( const Point3D& point ) const;              
        //\}
 
 
        //\{
        static Point3D vectorProduct(const Point3D& v1, const Point3D& v2);     
        static Point3D calcIntersectionPointOfVectorWithPlane(const Point3D& PlaneStartpoint,
                        const Point3D& PlaneNormal,
                        const Point3D& VectorStartpoint,
                        const Point3D& VectorDirection);
        static double getDistanceBetweenPoints(const Point3D& pt1, const Point3D& pt2); 
        //\}
 
 
        //\{
 
 
        std::istream& read (std::istream& is);  // , UINT32 version);   ///< Reads a Point3D from an input stream
        void read (const BYTE*& buf);   // , UINT32 version);                   ///< Reads a Point3D from a memory buffer and increments the buffer pointer
        std::ostream& write (std::ostream& os) const;   // , UINT32 version) const;     ///< Writes a Point3D to an output stream
        void write (BYTE*& buf) const;  //, UINT32 version) const;                      ///< Writes a Point2D to a memory buffer and increments the buffer pointer
        std::string toString() const;                                                   
 
        //\}
 
        static std::streamsize getSerializedSize();     // UINT32 version);     ///< Returns the number of bytes this object needs in serialized form
 
        friend inline bool operator==(const Point3D &, const Point3D &);
        friend inline bool operator!=(const Point3D &, const Point3D &);
        friend inline const Point3D operator+(const Point3D &, const Point3D &);
        friend inline const Point3D operator-(const Point3D &, const Point3D &);
        friend inline double operator*(const Point3D &, const Point3D &);
        friend inline const Point3D operator*(double, const Point3D &);
        friend inline const Point3D operator*(const Point3D &, double);
        friend inline const Point3D operator-(const Point3D &);
        friend inline const Point3D operator/(const Point3D &, double);
};
 
std::ostream& operator<<(std::ostream& os, const Point3D& point);       
 
// Inline functions
 
inline Point3D & Point3D::operator+= ( const Point3D & point )
{
        m_x += point.m_x;
        m_y += point.m_y;
        m_z += point.m_z;
        return *this;
}
 
inline Point3D & Point3D::operator-= ( const Point3D & point )
{
        m_x -= point.m_x;
        m_y -= point.m_y;
        m_z -= point.m_z;
        return *this;
}
 
inline Point3D & Point3D::operator/= ( double divisor )
{
        assert(!fuzzyCompare(divisor, 0.0));
        m_x /= divisor;
        m_y /= divisor;
        m_z /= divisor;
 
        return *this;
}
 
inline bool operator==(const Point3D &p1, const Point3D &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)))
                   && (fuzzyCompare(p1.m_z, p2.m_z)
                           || (isNaN(p1.m_z) && isNaN(p2.m_z)));
}
inline bool operator!=(const Point3D &p1, const Point3D &p2)
{
        return ! operator==(p1, p2);
}
 
inline const Point3D operator+(const Point3D &p1, const Point3D &p2)
{
        return Point3D(p1.m_x + p2.m_x, p1.m_y + p2.m_y, p1.m_z + p2.m_z);
}
 
 
inline const Point3D operator-(const Point3D &p1, const Point3D &p2)
{
        return Point3D(p1.m_x - p2.m_x, p1.m_y - p2.m_y, p1.m_z - p2.m_z);
}
 
// wert = v1 * v2
inline double operator*(const Point3D &p1, const Point3D &p2)
{
        return ((p1.m_x * p2.m_x) + (p1.m_y * p2.m_y) + (p1.m_z * p2.m_z));
}
 
 
inline const Point3D operator*(const Point3D &p, double factor)
{
        return Point3D(p.m_x * factor, p.m_y * factor, p.m_z * factor);
}
 
inline const Point3D operator*(double factor, const Point3D &p)
{
        return Point3D(p.m_x * factor, p.m_y * factor, p.m_z * factor);
}
 
 
inline const Point3D operator-(const Point3D &p)
{
        return Point3D(-p.m_x, -p.m_y, -p.m_z);
}
 
inline const Point3D operator/(const Point3D &p, double divisor)
{
        assert(fuzzyCompare(divisor, 0.0) == false);
        return Point3D(p.m_x / divisor, p.m_y / divisor, p.m_z / divisor);
}
 
// ////////////////////////////////////////////////////////////
 
}       // namespace datatypes
 
 
#endif