4DVector.inl

#pragma once
 
BEGIN_MOOTOOLS_NAMESPACE
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
template <class TYPE> inline C4DTVector<TYPE>::C4DTVector()
{
    t = 1;
}
 
template <class TYPE> inline C4DTVector<TYPE>::C4DTVector(const C4DTVector& plane)
{
    dir = plane.dir;
    t = plane.t;
}
 
template <class TYPE> inline C4DTVector<TYPE>::C4DTVector(const C3DTPoint<TYPE>& pt1, const C3DTPoint<TYPE>& pt2, const C3DTPoint<TYPE>& pt3, bool normalize)
{
    InitPlane(pt1, pt2, pt3, normalize);
}
 
template <class TYPE> inline void C4DTVector<TYPE>::Serialize(CXArchive& ar)
{
    if (ar.IsStoring())
    {
        ar << dir.x;
        ar << dir.y;
        ar << dir.z;
        ar << t;
    }
    else
    {
        ar >> dir.x;
        ar >> dir.y;
        ar >> dir.z;
        ar >> t;
    }
}
 
template <class TYPE> inline bool C4DTVector<TYPE>::InitPlane(const C3DTPoint<TYPE>& pt1, const C3DTPoint<TYPE>& pt2, const C3DTPoint<TYPE>& pt3, bool normalize)
{
    // Compute the normal of the three first point
    C3DVectorD vect1(pt1, pt2);
    C3DVectorD vect2(pt1, pt3);
 
    // If point are colinear normal is 0 0 0
    // normal coordinate are coef a, b, c
    dir.x = (TYPE)(vect1.y * vect2.z - vect1.z * vect2.y);
    dir.y = (TYPE)(vect1.z * vect2.x - vect1.x * vect2.z);
    dir.z = (TYPE)(vect1.x * vect2.y - vect1.y * vect2.x);
 
    if (normalize)
    {
        double length = dir.Length();
        if (length < PRECISION_LIMIT)
        {
            XTRACE(trace3DModule, 0, "template <class TYPE> C4DTVector<TYPE>::InitPlane: Warning null vector\n");
            dir.Init(1.0, 0, 0);
            t = 1;
 
            return false;
        }
 
        dir /= length;
    }
 
    // plan equation is ax+by+cz+t = 0 : compute t for point[0]
    t = -pt1.x*dir.x - pt1.y*dir.y - pt1.z*dir.z;
 
    return true;
}
 
template <class TYPE> inline double C4DTVector<TYPE>::GetSignedDistance(const C3DTPoint<TYPE>& pt) const // plane direction need to be normalized
{
    return pt.x*dir.x + pt.y*dir.y + pt.z*dir.z + t;
}
 
template <class TYPE> inline double C4DTVector<TYPE>::GetDistance(const C3DTPoint<TYPE>& pt) const
{
    return fabs(pt.x*dir.x + pt.y*dir.y + pt.z*dir.z + t);
}
 
template <class TYPE> inline C3DTPoint<TYPE> C4DTVector<TYPE>::GetProjection(const C3DTPoint<TYPE>& pt) const
{
    double d = GetSignedDistance(pt);
    return C3DPoint(pt.x - dir.x*d, pt.y - dir.y*d, pt.z - dir.z*d);
}
 
//////////////////////
// Mix type conversion (C3DTPoint<float> to C3DTPoint<double> for example)
template <class TYPE>
template <class TYPE2> C4DTVector<TYPE>::C4DTVector(const C4DTVector<TYPE2>& plane)
{
    dir.x = (TYPE)plane.dir.x;
    dir.y = (TYPE)plane.dir.y;
    dir.z = (TYPE)plane.dir.z;
    t = (TYPE)plane.t;
}
 
template <class TYPE>
template <class TYPE2> C4DTVector<TYPE>& C4DTVector<TYPE>::operator=(const C4DTVector<TYPE2>& plane)
{
    dir.x = (TYPE)plane.dir.x;
    dir.y = (TYPE)plane.dir.y;
    dir.z = (TYPE)plane.dir.z;
    t = (TYPE)plane.t;
 
    return *this;
}
END_MOOTOOLS_NAMESPACE