Vector3D.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) 2005 Imetric 3D GmbH                                    *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  is distributed in the hope that it will be useful,      *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/
 
 
#pragma once
 
#include <cmath>
#include <cfloat>
 
#ifndef  F_PI
# define F_PI  3.1415926f
#endif
 
#ifndef  D_PI
# define D_PI  3.141592653589793
#endif
 
#ifndef  FLOAT_MAX
# define FLOAT_MAX 3.402823466E+38F
#endif
 
#ifndef  FLOAT_MIN
# define FLOAT_MIN 1.175494351E-38F
#endif
 
#ifndef  DOUBLE_MAX
# define DOUBLE_MAX 1.7976931348623157E+308    /* max decimal value of a "double"*/
#endif
 
#ifndef  DOUBLE_MIN
# define DOUBLE_MIN 2.2250738585072014E-308    /* min decimal value of a "double"*/
#endif
 
 
namespace Base {
template <class numT>
struct float_traits { };
 
template <>
struct float_traits<float> {
    typedef float float_type;
    static inline float_type pi() { return F_PI; }
    static inline float_type epsilon() { return FLT_EPSILON; }
    static inline float_type maximum() { return FLT_MAX; }
};
 
template <>
struct float_traits<double> {
    typedef double float_type;
    static inline float_type pi() { return D_PI; }
    static inline float_type epsilon() { return DBL_EPSILON; }
    static inline float_type maximum() { return DBL_MAX; }
};
 
template <class _Precision>
class Vector3
{
public:
    typedef _Precision num_type;
    typedef float_traits<num_type> traits_type;
    static inline num_type epsilon() { return traits_type::epsilon(); }
 
    _Precision x; 
    _Precision y; 
    _Precision z; 
 
    explicit Vector3 (_Precision fx = 0.0, _Precision fy = 0.0, _Precision fz = 0.0);
    Vector3 (const Vector3<_Precision>& rcVct);
 
    _Precision & operator [] (unsigned short usIndex);
    const _Precision & operator [] (unsigned short usIndex) const;
    Vector3 operator +  (const Vector3<_Precision>& rcVct) const;
    Vector3 operator &  (const Vector3<_Precision>& rcVct) const;
    Vector3 operator -  (const Vector3<_Precision>& rcVct) const;
    Vector3 operator - (void) const;
    Vector3 & operator += (const Vector3<_Precision>& rcVct);
    Vector3 & operator -= (const Vector3<_Precision>& rcVct);
    Vector3 operator * (_Precision fScale) const;
    Vector3 operator / (_Precision fDiv) const;
    Vector3 & operator *= (_Precision fScale);
    Vector3 & operator /= (_Precision fDiv);
    Vector3 & operator =  (const Vector3<_Precision>& rcVct);
    _Precision operator *  (const Vector3<_Precision>& rcVct) const;
    _Precision Dot (const Vector3<_Precision>& rcVct) const;
    Vector3 operator %  (const Vector3<_Precision>& rcVct) const;
    Vector3 Cross (const Vector3<_Precision>& rcVct) const;
 
    bool operator != (const Vector3<_Precision>& rcVct) const;
    bool operator == (const Vector3<_Precision>& rcVct) const;
 
    bool IsOnLineSegment (const Vector3<_Precision>& startVct, const Vector3<_Precision>& endVct) const;
 
    void ScaleX (_Precision f);
    void ScaleY (_Precision f);
    void ScaleZ (_Precision f);
    void Scale (_Precision fX, _Precision fY, _Precision fZ);
    void MoveX (_Precision f);
    void MoveY (_Precision f);
    void MoveZ (_Precision f);
    void Move (_Precision fX, _Precision fY, _Precision fZ);
    void RotateX (_Precision f);
    void RotateY (_Precision f);
    void RotateZ (_Precision f);
 
    void Set (_Precision fX, _Precision fY, _Precision fZ);
 
    _Precision Length (void) const;
    _Precision Sqr (void) const;
    Vector3 & Normalize (void);
    _Precision GetAngle (const Vector3 &rcVect) const;
    void TransformToCoordinateSystem (const Vector3 &rclBase, const Vector3 &rclDirX, const Vector3 &rclDirY);
    bool IsEqual(const Vector3 &rclPnt, _Precision tol) const;
    Vector3 & ProjectToPlane (const Vector3 &rclBase, const Vector3 &rclNorm);
    void ProjectToPlane (const Vector3 &rclBase, const Vector3 &rclNorm, Vector3 &rclProj) const;
 
    Vector3 & ProjectToLine (const Vector3 &rclPoint, const Vector3 &rclLine);
    Vector3 Perpendicular(const Vector3 &rclBase, const Vector3 &rclDir) const;
    _Precision DistanceToPlane (const Vector3 &rclBase, const Vector3 &rclNorm) const;
    _Precision DistanceToLine (const Vector3 &rclBase, const Vector3 &rclDirect) const;
    Vector3 DistanceToLineSegment (const Vector3& rclP1, const Vector3& rclP2) const;
};
 
// global functions
 
template <class _Precision>
inline _Precision Distance (const Vector3<_Precision> &v1, const Vector3<_Precision> &v2)
{
    _Precision x=v1.x-v2.x, y=v1.y-v2.y, z=v1.z-v2.z;
    return static_cast<_Precision>(sqrt((x * x) + (y * y) + (z * z)));
}
 
template <class _Precision>
inline _Precision DistanceP2 (const Vector3<_Precision> &v1, const Vector3<_Precision> &v2)
{
    _Precision x=v1.x-v2.x, y=v1.y-v2.y, z=v1.z-v2.z;
    return x * x + y * y + z * z;
}
 
template <class _Precision>
inline Vector3<_Precision> operator * (_Precision fFac, const Vector3<_Precision> &rcVct)
{
    return Vector3<_Precision>(rcVct.x * fFac, rcVct.y * fFac, rcVct.z * fFac);
}
 
template <class _Pr1, class _Pr2>
inline Vector3<_Pr1> toVector(const Vector3<_Pr2>& v)
{
    return Vector3<_Pr1>(static_cast<_Pr1>(v.x),static_cast<_Pr1>(v.y),static_cast<_Pr1>(v.z));
}
 
typedef Vector3<float>  Vector3f;
typedef Vector3<double> Vector3d;
 
} // namespace Base