3DPoint.h

Go to the documentation of this file.

//! @file 3DPoint.h
//! @brief C3DTPoint template class definition for handling x, y, z 3D point coordinate
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DPOINT_H__CA6BC29E_FAC2_11D1_A0DE_000000000000__INCLUDED_)
#define AFX_3DPOINT_H__CA6BC29E_FAC2_11D1_A0DE_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#ifdef _DEBUG
#include "StringTools.h"
#endif
 
#include "Point.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
//! @class C3DTPoint
//! @brief The class defines an x, y, z 3D point which can use int, float or double
//! 
//! @tparam TYPE
//! can be int (C3DPointI), float (C3DPoint or C3DPointF) or double (C3DPointD)
template<class TYPE> class C3DTPoint : public CPt
{
    friend class C3DPointList;
 
    public:
    TYPE x, y, z;
 
    public:
    C3DTPoint();
    C3DTPoint(TYPE *val);
    C3DTPoint(int refx, int refy, int refz);
    C3DTPoint(float refx, float refy, float refz);
    C3DTPoint(double refx, double refy, double refz);
    C3DTPoint(const C3DTPoint& pt);
    C3DTPoint(const C3DTPoint& pt, const C3DTVector<TYPE>& vect, bool add); //!< if add = true, the point is point = pt+vect, if add = false,  point = pt-vect
 
    //! @name Access functions
    //! Get access to the 3D point x, y, z values
    //!
    //! @{
    TYPE& operator[](int i);
    const TYPE& operator[](int i) const;
    TYPE* ValPtr();
    const TYPE* ValPtr() const;
 
    //! @}
 
    unsigned int SizeOf() const;
 
    //! @name Operators
    //!
    //! @{
    double operator *(const C4DTVector<TYPE>& vect) const;
    C3DTPoint operator *(double value) const;
    //template <class TYPE> friend C3DTPoint operator *(double value, const C3DTPoint& pt);
    double Mult(const double& xx, const double& yy, const double& zz) const;
    C3DTPoint& operator=(const C3DTPoint& src);
    C3DTPoint& operator=(const C3DTVector<TYPE>& vect);
    C3DTPoint operator-(const C3DTVector<TYPE>& vect1) const;
    C3DTPoint operator+(const C3DTVector<TYPE>& vect1) const;
    C3DTPoint operator +(const C3DTPoint& pt1) const;
    C3DTPoint operator -(const C3DTPoint& pt1) const;
    C3DTPoint operator +(const C4DTVector<TYPE>& pt1) const;
    C3DTPoint operator /(double weight) const;
    C3DTPoint& operator -=(const C3DTPoint& pt);
    C3DTPoint& operator +=(const C3DTPoint& pt);
    C3DTPoint& operator -=(const C3DTVector<TYPE>& pt);
    C3DTPoint& operator +=(const C3DTVector<TYPE>& pt);
    C3DTPoint& operator *=(double weight);
    C3DTPoint& operator /=(double weight);
    bool operator==(const C3DTPoint& src) const;
    bool operator!=(const C3DTPoint& src) const;
 
    //! @}
 
    C3DPointI Floor() const;
    C3DPointI Ceil() const;
 
    //////////////////////
    //! @name Mix type conversion (C3DTPoint<float> to C3DTPoint<double> for example)
    //! @{
    template <class TYPE2> C3DTPoint(const C3DTPoint<TYPE2>& pt);
    template <class TYPE2> C3DTPoint(const C3DTVector<TYPE2>& pt);
    template <class TYPE2> C3DTPoint& operator=(const C3DTPoint<TYPE2>& pt);
 
    //! @}
 
    void Init(TYPE x = (TYPE)0.0, TYPE y = (TYPE)0, TYPE z = (TYPE)0);
    void Swap(unsigned int swapMode);
    void SubstractTo(const C3DTPoint& pt); //!< return this = pt-this, instead this = this-pt. This can be used for fast computation (using the standard operator return a C3DPointT)
    void Offset(TYPE value); //!< Add value to x, y, z
 
    // Check value
    bool IsAnormal() const; //!< either infinite or nan. Zero and denormalized value are allowed.
    bool IsInfinite() const; //!< Check if one of the coordinate has inf value.
    bool IsNan(bool resetToZero = false); //!< Check if one of the coordinate has nan value. resetToZero nan = true, reset coordinates to zero if any.
 
    virtual void To4DPoint(C4DPoint& pt) const;
    void SetValues(const TYPE *values3t); //!< Set point from 3 TYPE
    void GetFloat(float *values3f) const; //!< Get point and fill 3 floats
    void SetFloat(const float *values3f); //!< Set point from 3 floats
    void GetDouble(double *values3d) const; //!< Get point and fill 3 doubles
    void SetDouble(const double *values3d); //!< Set point from 3 doubles
 
    virtual CPt& operator=(const C4DPoint& pt);
 
    virtual void Serialize(CXArchive& ar);
 
    virtual CPt& operator=(const CPt& refpoint);
 
    #ifdef _DEBUG
    virtual void Dump() const;
 
    virtual bool IsKindOf(unsigned int classid) const;
    virtual unsigned int ClassID() const;
    #endif
};
 
//////////////////////
// Mix type conversion (C3DTPoint<float> to C3DTPoint<double> for example)
template <class TYPE>
template <class TYPE2> C3DTPoint<TYPE>::C3DTPoint(const C3DTPoint<TYPE2>& pt)
{
    XASSERT(ClassID() != pt.ClassID()); // (the default operator should be called if same type)
 
    x = (TYPE)pt.x;
    y = (TYPE)pt.y;
    z = (TYPE)pt.z;
}
 
template <class TYPE>
template <class TYPE2> C3DTPoint<TYPE>::C3DTPoint(const C3DTVector<TYPE2>& vect)
{
    x = (TYPE)vect.x;
    y = (TYPE)vect.y;
    z = (TYPE)vect.z;
}
 
template <class TYPE>
template <class TYPE2> C3DTPoint<TYPE>& C3DTPoint<TYPE>::operator=(const C3DTPoint<TYPE2>& pt)
{
    XASSERT(ClassID() != pt.ClassID()); // (the default operator should be called if same type)
 
    x = (TYPE)pt.x;
    y = (TYPE)pt.y;
    z = (TYPE)pt.z;
 
    CPt::operator=(pt);
 
    return *this;
}
 
template <typename TYPE> class CHashMethods<C3DTPoint<TYPE> >  // Keep space between > > for Linux C98
{
public:
    static inline bool HashCompare(const C3DTPoint<TYPE>& pt1, const C3DTPoint<TYPE>& pt2)
    {
        if (pt1.x != pt2.x || pt1.y != pt2.y || pt1.z != pt2.z)
            return false;
 
        return true;
    }
 
    static inline unsigned int HashValue(const C3DTPoint<TYPE>& hash)
    {
        return CHashMethods<TYPE>::HashValue(hash.x + hash.y + hash.z);
    }
};
 
template <> inline unsigned int CHashMethods<C3DTPoint<int> >::HashValue(const C3DTPoint<int>& hash)  // Keep space between > > for Linux C98
{
    return HashMixValue(hash.x + HashMixValue(hash.y)) + hash.z;
}
 
DLL_3DFUNCTION bool GetXYZSwap(unsigned int swapMode, int& coord1, int& coord2, int& invert);
DLL_3DFUNCTION bool IsInBox(const C3DPoint& refpt, const C3DPoint& pt1, const C3DPoint& pt2);
DLL_3DFUNCTION C3DPoint NoisyWaveFunc(const C3DPoint& refpt, const C3DPoint& upperleft, const C3DVector& length, double amplitude, double wavelength, double phase);
DLL_3DFUNCTION double GetCompacityFactor2(const C3DPoint& pt1, const C3DPoint& pt2, const C3DPoint& pt3);
DLL_3DFUNCTION double GetCompacityFactor(const C3DPoint& pt1, const C3DPoint& pt2, const C3DPoint& pt3);
 
END_MOOTOOLS_NAMESPACE
 
#include "3DVector.h"
#include "4DVector.h"
#include "3DPoint.inl"
 
BEGIN_MOOTOOLS_NAMESPACE
 
/////////////////////////////////////////////////////////////////////
// Specialization
//////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
template<> inline unsigned int C3DTPoint<int>::ClassID() const
{
    return MAKE_CUSTOM_ID('3', 'D', 'P', 'I');
}
 
template<> inline unsigned int C3DTPoint<float>::ClassID() const
{
    return MAKE_CUSTOM_ID('3', 'D', 'P', 'F');
}
 
template<> inline unsigned int C3DTPoint<double>::ClassID() const
{
    return MAKE_CUSTOM_ID('3', 'D', 'P', 'D');
}
#endif
 
//////////////////////////////////////////////////////////////////////
// Implementation
//////////////////////////////////////////////////////////////////////
 
#ifdef _DEBUG
template <class TYPE> void C3DTPoint<TYPE>::Dump() const
{
    XTRACE(_T("%.5f %.5f %.5f\n"), x, y, z);
    CPt::Dump();
}
 
template <> inline void C3DTPoint<int>::Dump() const
{
    XTRACE(_T("%d %d %d\n"), x, y, z);
    CPt::Dump();
}
#endif //_DEBUG
 
template <class TYPE> void C3DTPoint<TYPE>::Init(TYPE x, TYPE y, TYPE z)
{
    this->x = (TYPE)x;
    this->y = (TYPE)y;
    this->z = (TYPE)z;
}
 
template <class TYPE> void C3DTPoint<TYPE>::Serialize(CXArchive& ar)
{
    CPt::Serialize(ar);
 
    if (ar.IsStoring())
    {
        ar << x;
        ar << y;
        ar << z;
    }
    else
    {
        ar >> x;
        ar >> y;
        ar >> z;
    }
}
 
template <class TYPE> void C3DTPoint<TYPE>::To4DPoint(C4DPoint& pt) const
{
    pt.size = 3;
    pt.value[0] = x;
    pt.value[1] = y;
    pt.value[2] = z;
}
 
template <class TYPE> CPt& C3DTPoint<TYPE>::operator=(const C4DPoint& pt)
{
    XASSERT(pt.size == 3);
    x = (TYPE)pt.value[0];
    y = (TYPE)pt.value[1];
    z = (TYPE)pt.value[2];
    return *this;
}
 
template<class TYPE> void C3DTPoint<TYPE>::Swap(unsigned int swapMode)
{
    // The order of inversion is important (swap before invert)
    if (swapMode & SWAP_AXIS_FLAGS)
    {
        TYPE tmp;
        switch (swapMode & SWAP_AXIS_FLAGS)
        {
            default:
                XASSERT(0);
                break;
 
            case SWAP_XY:
                SWAP_VALUES(x, y, tmp);
                break;
            case SWAP_XZ:
                SWAP_VALUES(x, z, tmp);
                break;
            case SWAP_YZ:
                SWAP_VALUES(y, z, tmp);
                break;
        }
    }
 
    if (swapMode & SWAP_INVERT_FLAGS)
    {
        switch (swapMode & SWAP_INVERT_FLAGS)
        {
            default:
                XASSERT(0);
                break;
 
            case SWAP_INVERT_X:
                x = -x;
                break;
            case SWAP_INVERT_Y:
                y = -y;
                break;
            case SWAP_INVERT_Z:
                z = -z;
                break;
        }
    }
}
 
 
template <class TYPE> inline void  C3DTPoint<TYPE>::SetFloat(const float *values)
{
    x = (TYPE)values[0];
    y = (TYPE)values[1];
    z = (TYPE)values[2];
}
 
template <class TYPE> void C3DTPoint<TYPE>::GetFloat(float *values) const
{
    values[0] = x;
    values[1] = y;
    values[2] = z;
}
 
template <class TYPE> void C3DTPoint<TYPE>::GetDouble(double *values) const
{
    values[0] = x;
    values[1] = y;
    values[2] = z;
}
 
template <class TYPE> void C3DTPoint<TYPE>::SetDouble(const double *values)
{
    x = (TYPE)values[0];
    y = (TYPE)values[1];
    z = (TYPE)values[2];
}
 
template <class TYPE> CPt& C3DTPoint<TYPE>::operator=(const CPt& refpoint)
{
    XASSERT(refpoint.IsKindOf(C3DTPoint<TYPE>::ClassID()));
 
    x = ((C3DTPoint<TYPE>&)refpoint).x;
    y = ((C3DTPoint<TYPE>&)refpoint).y;
    z = ((C3DTPoint<TYPE>&)refpoint).z;
 
    return CPt::operator=(refpoint);
}
 
#ifdef _DEBUG
template<class TYPE>
bool C3DTPoint<TYPE>::IsKindOf(unsigned int classid) const
{
    if (C3DTPoint::ClassID() == classid)
        return true;
 
    return CPt::IsKindOf(classid);
}
 
template<class TYPE>
unsigned int C3DTPoint<TYPE>::ClassID() const
{
    XASSERT(0);
    return MAKE_CUSTOM_ID('3', 'D', 'P', 'T');
}
#endif
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_3DPOINT_H__CA6BC29E_FAC2_11D1_A0DE_000000000000__INCLUDED_)