spt_point3_vector3.h

Go to the documentation of this file.

/******************************************************************************
SP_Point3_Vector3.h

Vector and Point in 3D inheritance from SPtSpace class.

Modified from "RADIOSITY A Programmer's Perspective" by Ian Ashdown (1994)

Sukitti Punak   (10/24/2003)
Latest Update   (11/20/2003)
******************************************************************************/
#ifndef SPT_POINT3_VECTOR3_H
#define SPT_POINT3_VECTOR3_H

#include <cmath>

// Parent Class
#include "SPT_Space3.h"

// Associated Class
#include "SPT_Matrix3x3.h"


// Forward Declarations
template< typename T > class SPtVector3;
template< typename T > class SPtVector3T;

//===============================================================================================
//
//          C L A S S    D E C L A R A T I O N S
//
//===============================================================================================
// CLASS:   SPtPoint3  ***********************************************************
// Desc:  3-D Point
template< typename T >
class SPtPoint3 : public SPtSpace3< T >
{
    // Friend Class
    friend class SPtVector3<T>;

    // Friend Functions for Operator Overloading
    friend SPtPoint3< T > operator+( const SPtPoint3< T > &, const SPtVector3< T > & );
    friend SPtPoint3< T > operator+( const SPtVector3< T > &, const SPtPoint3< T > & );

// Data Members  --------------------------------------------------------------
public:
    // Constructors
    //SPtPoint3() : SPtSpace3() { };
    SPtPoint3( T xval = 0, T yval = 0, T zval = 0 ) : SPtSpace3< T >( xval, yval, zval ) { }
    SPtPoint3( const SPtPoint3 &p ) : SPtSpace3< T >( p.x, p.y, p.z ) { }

    // Operators  ------------------------------------
    // assign scalar
    SPtPoint3< T > &operator=( T );
    // assign point
    SPtPoint3< T > &operator=( const SPtPoint3< T > & );
    // assign vector
    SPtPoint3< T > &operator=( const SPtVector3< T > & );

}; // END:  SPtPoint3
//===============================================================================================


//===============================================================================================
// CLASS:   SPtVector3  **********************************************************
// Desc:  3-D Vector
template< typename T >
class SPtVector3 : public SPtSpace3< T >
{
    // Friend Functions for Operator Overloading
    // Add vector v2 to vector v1
    friend SPtVector3< T > operator+( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
    {   return SPtVector3< T >( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z );    }
    // subtract vector v2 from vector v1
    friend SPtVector3< T > operator-( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
    {   return SPtVector3< T >( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z );    }
    // multiply vector v by scalar s
    friend SPtVector3< T > operator*( const SPtVector3< T > &v, T s )
    {   return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }
    friend SPtVector3< T > operator*( const SPtVector3< T > &v, double s );
    //{ return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }
    friend SPtVector3< T > operator*( const SPtVector3< T > &v, float s )
    {   return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }
    friend SPtVector3< T > operator*( const SPtVector3< T > &v, long s )
    {   return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }
    friend SPtVector3< T > operator*( const SPtVector3< T > &v, int s )
    {   return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }
    // multiply scalar s by vector v
    friend SPtVector3< T > operator*( T s, const SPtVector3< T > &v )
    {   return v * s;   }
    friend SPtVector3< T > operator*( double s, const SPtVector3< T > &v );
    //{ return v * s;   }
    friend SPtVector3< T > operator*( float s, const SPtVector3< T > &v )
    {   return v * s;   }
    friend SPtVector3< T > operator*( long s, const SPtVector3< T > &v )
    {   return v * s;   }
    friend SPtVector3< T > operator*( int s, const SPtVector3< T > &v )
    {   return v * s;   }
    // divide vector v by scalar s
    friend SPtVector3< T > operator/( const SPtVector3< T > &v, double s )
    {   return SPtVector3< T >( v.x / s, v.y / s, v.z / s );    }
    friend SPtVector3< T > operator/( const SPtVector3< T > &v, float s )
    {   return SPtVector3< T >( v.x / s, v.y / s, v.z / s );    }
    friend SPtVector3< T > operator/( const SPtVector3< T > &v, long s )
    {   return SPtVector3< T >( v.x / s, v.y / s, v.z / s );    }
    friend SPtVector3< T > operator/( const SPtVector3< T > &v, int s )
    {   return SPtVector3< T >( v.x / s, v.y / s, v.z / s );    }
    // Return dot product of vector v1 and v2
    friend T InnerProduct( const SPtVector3< T > &, const SPtVector3< T > & );
    friend T DotProduct( const SPtVector3< T > &, const SPtVector3< T > & );
    friend T operator*( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
    {   return ( v1.x*v2.x + v1.y*v2.y + v1.z*v2.z );   };

    // Return cross product of vecter v1 and v2
    friend SPtVector3< T > CrossProduct( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
    {   return SPtVector3< T >( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x );  }
    friend SPtVector3< T > operator%( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
    {   return SPtVector3< T >( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x );  }
    
    // Friend Functions for Overloaded Operators with class SPtMatrix3x3
    friend SPtVector3< T > operator*( const SPtMatrix3x3< T > &M, const SPtVector3< T > &v )
    {
        return SPtVector3< T >( M.Get(0,0)*v.x + M.Get(0,1)*v.y + M.Get(0,2)*v.z,
                                M.Get(1,0)*v.x + M.Get(1,1)*v.y + M.Get(1,2)*v.z,
                                M.Get(2,0)*v.x + M.Get(2,1)*v.y + M.Get(2,2)*v.z
                               );
    }



// Member Functions -----------------------------------------------------------
public:
    // Constructors
    SPtVector3() : SPtSpace3< T >() { }
    SPtVector3( T xval, T yval, T zval ) : SPtSpace3< T >( xval, yval, zval ) { }
    SPtVector3( const SPtVector3< T > &v ) : SPtSpace3< T >( v.x, v.y, v.z ) { }
    //SPtVector3( const SPtVector3T< T > &v ) : SPtSpace3< T >( v.GetX(), v.GetY(), v.GetZ() ) { }
    SPtVector3( const SPtPoint3< T > &p ) : SPtSpace3< T >( p.x, p.y, p.z ) { }
    SPtVector3( const SPtPoint3< T > &start, const SPtPoint3< T > &end ) 
        : SPtSpace3< T >( end.x - start.x, end.y - start.y, end.z - start.z ) { }

    // return vector length
    T Length();
    // Normalize and return the vector
    SPtVector3< T > &Norm();

    // Operators  ------------------------------------
    // assign scalar
    SPtVector3< T > &operator=( T );
    // assign point
    SPtVector3< T > &operator=( const SPtPoint3< T > & );
    // assign vector
    SPtVector3< T > &operator=( const SPtVector3< T > & );
    // add/assign vector v
    SPtVector3< T > &operator+=( const SPtVector3< T > & );
    // subtract/assign vector v
    SPtVector3< T > &operator-=( const SPtVector3< T > & );
    // multiply/assign by scalar s
    SPtVector3< T > &operator*=( T );
    // divide/assign by scalar s
    SPtVector3< T > &operator/=( T );
    // negation
    SPtVector3< T > operator-() const;

    // V1*V2_t ==> Matrix3x3
    SPtMatrix3x3< T > operator*( const SPtVector3T< T > & ) const;
    // V1_t*V1_t ==> V2
    T   SelfInnerProduct() const;
    // V1*V1_t ==> Matrix3x3
    SPtMatrix3x3< T > SelfOuterProduct() const;

    // return the (3-by-3) star matrix of this vector
    SPtMatrix3x3< T > GetStarMatrix() const;

}; // END:  SPtVector3
//===============================================================================================


//===============================================================================================
// CLASS:   SPtVector3T  **********************************************************
// Desc:  3-D Vector
template< typename T >
class SPtVector3T : public SPtVector3< T >
{
    // Overloaded Operator   --------------------------------------------------
    friend ostream &operator<<( ostream &, const SPtVector3T< T > & );


// Member Functions     -------------------------------------------------------
public:
    // Constructors
    SPtVector3T() : SPtVector3< T >() { }
    SPtVector3T( T xval, T yval, T zval ) : SPtVector3< T >( xval, yval, zval ) { }
    SPtVector3T( const SPtVector3T< T > &v ) : SPtVector3< T >( v.x, v.y, v.z ) { }
    SPtVector3T( const SPtVector3< T > &v ) : SPtVector3< T >( v.GetX(), v.GetY(), v.GetZ() ) { }   // conversion constructor
    SPtVector3T( const SPtPoint3< T > &p ) : SPtVector3< T >( p.GetX(), p.GetY(), p.GetZ() ) { }
    SPtVector3T( const SPtPoint3< T > &start, const SPtPoint3< T > &end ) 
        : SPtVector3< T >( end.GetX() - start.GetX(), end.GetY() - start.GetY(), end.GetZ() - start.GetZ() ) { }

    // Overloaded for * with a 3-by-3 matrix
    SPtVector3T operator*( const SPtMatrix3x3< T > & );

    // Overloaded for * with a SPtVector3
    T   operator*( const SPtVector3< T > & ) const;

}; // END:  SPtVector3
//===============================================================================================



//===============================================================================================
//
//          M E M B E R    F U N C T I O N    D E F I N I T I O N S
//
//===============================================================================================
// START:   SPtPoint3 Member Functions  ******************************************

// Overloaded Operators  -----------------------------

// assign scalar
template< typename T >
SPtPoint3< T > &SPtPoint3< T >::operator=( T s )
{
    x = y = z = s;
    return *this;
}

// assign point
template< typename T >
SPtPoint3< T > &SPtPoint3< T >::operator=( const SPtPoint3< T > &p )
{
    x = p.x;
    y = p.y;
    z = p.z;
    return *this;
}

// assign vector
template< typename T >
SPtPoint3< T > &SPtPoint3< T >::operator=( const SPtVector3< T > &v )
{
    x = v.GetX();
    y = v.GetY();
    z = v.GetZ();
    return *this;
}

// Friend Functions for Operator Overloading  --------
// add vector v to point p
template< typename T >
SPtPoint3< T > operator+( const SPtPoint3< T > &p, const SPtVector3< T > &v )
{   return SPtPoint3< T >( p.x + v.GetX(), p.y + v.GetY(), p.z + v.GetZ() );    }

// add point p to vector v
template< typename T >
SPtPoint3< T > operator+( const SPtVector3< T > &v, const SPtPoint3< T > &p )
{   return p + v;   }

// END:     SPtPoint3 Member Functions  ******************************************
//===============================================================================================


//===============================================================================================
// Start:   SPtVector3 Member Functions  *****************************************

// return vector length
template< typename T >
T SPtVector3< T >::Length() { return sqrt( x*x + y*y + z*z ); }

// Normalize and return the vector
template< typename T >
SPtVector3< T > &SPtVector3< T >::Norm()
{
    T len = Length();
    if ( fabs(len) < 1E-40 )    len = 1.0;
    x /= len;
    y /= len;
    z /= len;
    return *this;
}

// Operators  ------------------------------------
// assign scalar
template< typename T >
SPtVector3< T > &SPtVector3< T >::operator=( T s )
{
    x = y = z = s;
    return *this;
}

// assign point
template< typename T >
SPtVector3< T > &SPtVector3< T >::operator=( const SPtPoint3< T > &p )
{
    x = p.x;
    y = p.y;
    z = p.z;
    return *this;
}

// assign vector
template< typename T >
SPtVector3< T > &SPtVector3< T >::operator=( const SPtVector3< T > &v )
{
    x = v.x;
    y = v.y;
    z = v.z;
    return *this;
}

// add/assign vector v
template< typename T >
SPtVector3< T > &SPtVector3< T >::operator+=( const SPtVector3< T > &v )
{
    x += v.x;
    y += v.y;
    z += v.z;
    return *this;
}

// subtract/assign vector v
template< typename T >
SPtVector3< T > &SPtVector3< T >::operator-=( const SPtVector3< T > &v )
{
    x -= v.x;
    y -= v.y;
    z -= v.z;
    return *this;
}

// multiply/assign by scalar s
template< typename T >
SPtVector3< T > &SPtVector3< T >::operator*=( T s )
{
    x *= s;
    y *= s;
    z *= s;
    return *this;
}

// divide/assign by scalar s
template< typename T >
SPtVector3< T > &SPtVector3< T >::operator/=( T s )
{
    x /= s;
    y /= s;
    z /= s;
    return *this;
}

// negation
template< typename T >
SPtVector3< T > SPtVector3< T >::operator-() const
{   return SPtVector3< T >( -x, -y, -z );   }

// V1*V2_t ==> Matrix3x3
template< typename T >
SPtMatrix3x3< T > SPtVector3< T >::operator*( const SPtVector3T< T > &V ) const
{
    return SPtMatrix3x3< T >(   x*V.x, x*V.y, x*V.z,
                                y*V.x, y*V.y, y*V.z,
                                z*V.x, z*V.y, z*V.z
                            );
}

// V1_t*V1_t ==> V2
template< typename T >
T   SPtVector3< T >::SelfInnerProduct() const
{
    return x*x + y*y + z*z;
}

// V1*V1_t ==> Matrix3x3
template< typename T >
SPtMatrix3x3< T > SPtVector3< T >::SelfOuterProduct() const
{
    return SPtMatrix3x3< T >(   x*x, x*y, x*z,
                                y*x, y*y, y*z,
                                z*x, z*y, z*z
                            );
}

// Return the (3-by-3) star matrix of this vector
//      |  0  -z   y  |
// v* = |  z   0  -x  |
//      | -y   x   0  |
template< typename T >
SPtMatrix3x3< T > SPtVector3< T >::GetStarMatrix() const
{
    return SPtMatrix3x3< T >(    0, -z,  y,
                                 z,  0, -x,
                                -y,  x,  0
                            );
}


/*
//=============================================================================
// Friend Overloaded Operators
// Add vector v2 to vector v1
template< typename T >
SPtVector3< T > operator+( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
{   return SPtVector3< T >( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z );    }

// subtract vector v2 from vector v1
template< typename T >
SPtVector3< T > operator-( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
{   return SPtVector3< T >( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z );    }

// multiply vector v by scalar s
template< typename T >
SPtVector3< T > operator*( const SPtVector3< T > &v, T s )
{   return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }
template< typename T >
SPtVector3< T > operator*( const SPtVector3< T > &v, double s )
{   return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }
template< typename T >
SPtVector3< T > operator*( const SPtVector3< T > &v, float s )
{   return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }
template< typename T >
SPtVector3< T > operator*( const SPtVector3< T > &v, long s )
{   return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }
template< typename T >
SPtVector3< T > operator*( const SPtVector3< T > &v, int s )
{   return  SPtVector3< T >( v.x * s, v.y * s, v.z * s );   }

// multiply scalar s by vector v
template< typename T >
SPtVector3< T > operator*( T s, const SPtVector3< T > &v )
{   return v * s;   }
template< typename T >
SPtVector3< T > operator*( double s, const SPtVector3< T > &v )
{   return v * s;   }
template< typename T >
SPtVector3< T > operator*( float s, const SPtVector3< T > &v )
{   return v * s;   }
template< typename T >
SPtVector3< T > operator*( long s, const SPtVector3< T > &v )
{   return v * s;   }
template< typename T >
SPtVector3< T > operator*( int s, const SPtVector3< T > &v )
{   return v * s;   }

// divide vector v by scalar s
template< typename T >
SPtVector3< T > operator/( const SPtVector3< T > &v, double s )
{   return SPtVector3< T >( v.x / s, v.y / s, v.z / s );    }
template< typename T >
SPtVector3< T > operator/( const SPtVector3< T > &v, float s )
{   return SPtVector3< T >( v.x / s, v.y / s, v.z / s );    }
template< typename T >
SPtVector3< T > operator/( const SPtVector3< T > &v, long s )
{   return SPtVector3< T >( v.x / s, v.y / s, v.z / s );    }
template< typename T >
SPtVector3< T > operator/( const SPtVector3< T > &v, int s )
{   return SPtVector3< T >( v.x / s, v.y / s, v.z / s );    }

// Return dot product of vector v1 and v2
template< typename T >
T InnerProduct( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
{   return ( v1.x*v2.x + v1.y*v2.y + v1.z*v2.z );   }
template< typename T >
T DotProduct( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
{   return ( v1.x*v2.x + v1.y*v2.y + v1.z*v2.z );   }
template< typename T >
T operator*( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
{   return ( v1.x*v2.x + v1.y*v2.y + v1.z*v2.z );   }

// Return cross product of vecter v1 and v2
template< typename T >
SPtVector3< T > CrossProduct( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
{   return SPtVector3< T >( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x );  }
template< typename T >
SPtVector3< T > operator%( const SPtVector3< T > &v1, const SPtVector3< T > &v2 )
{   return SPtVector3< T >( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x );  }

// Overloaded for * with a 3-by-3 matrix
template< typename T >
SPtVector3< T > operator*( const SPtMatrix3x3< T > &M, const SPtVector3< T > &v )
{
    return SPtVector3< T >( M.Get(0,0)*v.x + M.Get(0,1)*v.y + M.Get(0,2)*v.z,
                            M.Get(1,0)*v.x + M.Get(1,1)*v.y + M.Get(1,2)*v.z,
                            M.Get(2,0)*v.x + M.Get(2,1)*v.y + M.Get(2,2)*v.z
                           );
}
*/
// END:     SPtVector3 Member Functions  *****************************************
//===============================================================================================


//===============================================================================================
// Start:   SPtVector3T Member Functions  *****************************************

// Friend Overloaded Operator  *******************************************************
template< typename T >
ostream &operator<<( ostream &output, const SPtVector3T< T > &s )
{
    output << "(" << s.GetX() << "," << s.GetY() << "," << s.GetZ() << ")";
    return output;
}


// Overloaded for * with a 3-by-3 matrix
template< typename T >
SPtVector3T< T > SPtVector3T< T >::operator*( const SPtMatrix3x3< T > &M )
{
    T   x, y, z;
    GetXYZ( x, y, z );
    return SPtVector3T< T >( x*M.Get(0,0) + y*M.Get(1,0) + z*M.Get(2,0),
                             x*M.Get(0,1) + y*M.Get(1,1) + z*M.Get(2,1),
                             x*M.Get(0,2) + y*M.Get(1,2) + z*M.Get(2,2)
                            );
}

// Overloaded for * with a SPtVector3
template< typename T >
T   SPtVector3T< T >::operator*( const SPtVector3< T > &V ) const
{
    T   x, y, z;
    GetXYZ( x, y, z );
    return x*V.x + y*V.y + z*V.z;
}


// END:     SPtVector3T Member Functions  *****************************************
//===============================================================================================

#endif