src/tetmesh/vector3.h

Go to the documentation of this file.

/***************************************************************************
                          vector3.h  -  description
                             -------------------
    begin                : Fri Feb 27 2004
    copyright            : (C) 2004 by Roman Geus
    email                : roman.geus@psi.ch
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef VECTOR3_H
#define VECTOR3_H
 
#include <iostream>
#include <cmath>
 
namespace mesh {

#define Real double
   
class Vector3
{
public:
    Real x, y, z;

public:
    inline Vector3()
    {
    }

    inline Vector3( Real fX, Real fY, Real fZ )
        : x( fX ), y( fY ), z( fZ )
    {
    }

    inline Vector3( Real afCoordinate[3] )
        : x( afCoordinate[0] ),
          y( afCoordinate[1] ),
          z( afCoordinate[2] )
    {
    }

    inline Vector3( int afCoordinate[3] )
    {
        x = (Real)afCoordinate[0];
        y = (Real)afCoordinate[1];
        z = (Real)afCoordinate[2];
    }

    inline Vector3( const Real* const r )
        : x( r[0] ), y( r[1] ), z( r[2] )
    {
    }

    inline Vector3( const Vector3& rkVector )
        : x( rkVector.x ), y( rkVector.y ), z( rkVector.z )
    {
    }

    inline Real operator [] ( unsigned i ) const
    {
        return *(&x+i);
    }

    inline Real& operator [] ( unsigned i )
    {
        return *(&x+i);
    }

    inline Vector3& operator = ( const Vector3& rkVector )
    {
        x = rkVector.x;
        y = rkVector.y;
        z = rkVector.z;

        return *this;
    }

    inline bool operator == ( const Vector3& rkVector ) const
    {
        return ( x == rkVector.x && y == rkVector.y && z == rkVector.z );
    }

    inline bool operator != ( const Vector3& rkVector ) const
    {
        return ( x != rkVector.x || y != rkVector.y || z != rkVector.z );
    }

    // arithmetic operations
    inline Vector3 operator + ( const Vector3& rkVector ) const
    {
        Vector3 kSum;

        kSum.x = x + rkVector.x;
        kSum.y = y + rkVector.y;
        kSum.z = z + rkVector.z;

        return kSum;
    }

    inline Vector3 operator - ( const Vector3& rkVector ) const
    {
        Vector3 kDiff;

        kDiff.x = x - rkVector.x;
        kDiff.y = y - rkVector.y;
        kDiff.z = z - rkVector.z;

        return kDiff;
    }

    inline Vector3 operator * ( Real fScalar ) const
    {
        Vector3 kProd;

        kProd.x = fScalar*x;
        kProd.y = fScalar*y;
        kProd.z = fScalar*z;

        return kProd;
    }

    inline Vector3 operator * ( const Vector3& rhs) const
    {
        Vector3 kProd;

        kProd.x = rhs.x * x;
        kProd.y = rhs.y * y;
        kProd.z = rhs.z * z;

        return kProd;
    }

    inline Vector3 operator / ( Real fScalar ) const
    {
        Vector3 kDiv;

        Real fInv = 1.0 / fScalar;
        kDiv.x = x * fInv;
        kDiv.y = y * fInv;
        kDiv.z = z * fInv;

        return kDiv;
    }

    inline Vector3 operator - () const
    {
        Vector3 kNeg;

        kNeg.x = -x;
        kNeg.y = -y;
        kNeg.z = -z;

        return kNeg;
    }

    inline friend Vector3 operator * ( Real fScalar, const Vector3& rkVector )
    {
        Vector3 kProd;

        kProd.x = fScalar * rkVector.x;
        kProd.y = fScalar * rkVector.y;
        kProd.z = fScalar * rkVector.z;

        return kProd;
    }

    // arithmetic updates
    inline Vector3& operator += ( const Vector3& rkVector )
    {
        x += rkVector.x;
        y += rkVector.y;
        z += rkVector.z;

        return *this;
    }

    inline Vector3& operator -= ( Real fScalar )
    {
        x -= fScalar;
        y -= fScalar;
        z -= fScalar;

        return *this;
    }

    inline Vector3& operator -= ( const Vector3& rkVector )
    {
        x -= rkVector.x;
        y -= rkVector.y;
        z -= rkVector.z;

        return *this;
    }

    inline Vector3& operator *= ( Real fScalar )
    {
        x *= fScalar;
        y *= fScalar;
        z *= fScalar;
        return *this;
    }

    inline Vector3& operator *= ( const Vector3& rkVector )
    {
        x *= rkVector.x;
        y *= rkVector.y;
        z *= rkVector.z;
        return *this;
    }

    inline Vector3& operator /= ( Real fScalar )
    {
        Real fInv = 1.0 / fScalar;

        x *= fInv;
        y *= fInv;
        z *= fInv;

        return *this;
    }

    inline Real length () const
    {
        return ::sqrt( x * x + y * y + z * z );
    }

    inline Real squared_length () const
    {
        return x * x + y * y + z * z;
    }

    inline Real dot_product(const Vector3& vec) const
    {
        return x * vec.x + y * vec.y + z * vec.z;
    }

    inline Real normalise()
    {
        Real fLength = length();

        // Will also work for zero-sized vectors, but will change nothing
        if (1.0 + fLength*fLength > 1.0)
            {
                Real fInvLength = 1.0 / fLength;
                x *= fInvLength;
                y *= fInvLength;
                z *= fInvLength;
            }

        return fLength;
    }

    inline Vector3 cross_product( const Vector3& rkVector ) const
    {
        Vector3 kCross;

        kCross.x = y * rkVector.z - z * rkVector.y;
        kCross.y = z * rkVector.x - x * rkVector.z;
        kCross.z = x * rkVector.y - y * rkVector.x;

        return kCross;
    }

    inline Vector3 mid_point( const Vector3& vec ) const
    {
        return Vector3(
                       ( x + vec.x ) * 0.5,
                       ( y + vec.y ) * 0.5,
                       ( z + vec.z ) * 0.5 );
    }

    inline bool operator < ( const Vector3& rhs ) const
    {
        if( x < rhs.x && y < rhs.y && z < rhs.z )
            return true;
        return false;
    }

    inline bool operator <= ( const Vector3& rhs ) const
    {
        if( x <= rhs.x && y <= rhs.y && z <= rhs.z )
            return true;
        return false;
    }

    inline bool operator < ( Real scalar ) const
    {
        if( x < scalar && y < scalar && z < scalar )
            return true;
        return false;
    }

    inline bool operator <= ( Real scalar ) const
    {
        if( x <= scalar && y <= scalar && z <= scalar )
            return true;
        return false;
    }

    inline bool operator > ( const Vector3& rhs ) const
    {
        if( x > rhs.x && y > rhs.y && z > rhs.z )
            return true;
        return false;
    }

    inline bool operator > ( Real scalar ) const
    {
        if( x > scalar && y > scalar && z > scalar )
            return true;
        return false;
    }

    inline bool operator >= ( Real scalar ) const
    {
        if( x >= scalar && y >= scalar && z >= scalar )
            return true;
        return false;
    }

    inline void make_floor( const Vector3& cmp )
    {
        if( cmp.x < x ) x = cmp.x;
        if( cmp.y < y ) y = cmp.y;
        if( cmp.z < z ) z = cmp.z;
    }

    inline void make_ceil( const Vector3& cmp )
    {
        if( cmp.x > x ) x = cmp.x;
        if( cmp.y > y ) y = cmp.y;
        if( cmp.z > z ) z = cmp.z;
    }

    inline Vector3 perpendicular(void) const
    {
        Vector3 perp = this->cross_product( Vector3::UNIT_X );

        // Check length
        if(perp.is_zero_length())
            {
                /* This vector is the Y axis multiplied by a scalar, so we have
                   to use another axis.
                */
                perp = this->cross_product( Vector3::UNIT_Y );
            }

        return perp;
    }

    inline bool is_zero_length(void) const
    {
        Real sqlen = (x * x) + (y * y) + (z * z);
        return (1.0 + sqlen == 1.0);

    }

    inline Vector3 normalised_copy(void) const
    {
        Vector3 ret = *this;
        ret.normalise();
        return ret;
    }

    inline Vector3 reflect(const Vector3& normal)
    {
        return Vector3( *this - ( 2 * this->dot_product(normal) * normal ) );
    }

    // special points
    static const Vector3 ZERO;
    static const Vector3 UNIT_X;
    static const Vector3 UNIT_Y;
    static const Vector3 UNIT_Z;
    static const Vector3 UNIT_SCALE;

    inline friend std::ostream& operator <<
        ( std::ostream& o, const Vector3& v )
    {
        o << "Vector3(" << v.x << ", " << v.y << ", " << v.z << ")";
        return o;
    }
};

#undef Real
} // namespace mesh

#endif

---