UT/UT_Vector2.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Rob Bairos
 *      Side Effects Software Inc.
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        UT_Vector2.h (C++)
 *
 *
 * COMMENTS:
 *      This class handles fpreal vectors of dimension 2.
 *
 * WARNING:
 *      This class should NOT contain any virtual methods, nor should it
 *      define more member data. The size of UT_Vector2 must always be 
 *      8 bytes (2 floats).
 */

#ifndef __UT_Vector2_h__
#define __UT_Vector2_h__

#include "UT_API.h"
#include <iostream.h>
#include <limits.h>
#include "UT_Math.h"
#include "UT_Assert.h"

class UT_IStream;
class UT_Vector2;
class UT_Vector3;
class UT_Vector4;
template <typename T> class UT_TMatrix2;

// Free floating functions:

// Operators that involve a UT_Vector2 object:
inline UT_Vector2       operator+(const UT_Vector2 &v1, const UT_Vector2 &v2);
inline UT_Vector2       operator-(const UT_Vector2 &v1, const UT_Vector2 &v2);
inline bool             operator<(const UT_Vector2 &v1, const UT_Vector2 &v2);
inline bool             operator<=(const UT_Vector2 &v1, const UT_Vector2 &v2);
inline bool             operator>(const UT_Vector2 &v1, const UT_Vector2 &v2);
inline bool             operator>=(const UT_Vector2 &v1, const UT_Vector2 &v2);
inline UT_Vector2       operator+(const UT_Vector2 &v, fpreal scalar);
inline UT_Vector2       operator-(const UT_Vector2 &v, fpreal scalar);
inline UT_Vector2       operator*(const UT_Vector2 &v, fpreal scalar);
inline UT_Vector2       operator/(const UT_Vector2 &v, fpreal scalar);
inline UT_Vector2       operator+(fpreal scalar, const UT_Vector2 &v);
inline UT_Vector2       operator-(fpreal scalar, const UT_Vector2 &v);
inline UT_Vector2       operator*(fpreal scalar, const UT_Vector2 &v);
inline UT_Vector2       operator/(fpreal scalar, const UT_Vector2 &v);
inline UT_Vector2       operator*(const UT_Vector2 &v, 
                                  const UT_TMatrix2<float> &mat);

/// The dot product
inline fpreal           dot      (const UT_Vector2 &v1, const UT_Vector2 &v2);
/// Cross product, which for 2d vectors results in a fpreal.
inline fpreal           cross    (const UT_Vector2 &v1, const UT_Vector2 &v2);

/// The orthogonal projection of a vector u onto a vector v
inline UT_Vector2       project  (const UT_Vector2 &u, const UT_Vector2 &v);

/// Multiplication of a row or column vector by a matrix (ie. right vs. left
/// multiplication respectively). The operator*() declared above is an alias 
/// for rowVecMult().
// @{
//
// Notes on optimisation of matrix/vector multiplies:
// - multiply(dest, mat) functions have been deprecated in favour of
// rowVecMult/colVecMult routines, which produce temporaries. For these to
// offer comparable performance, the compiler has to optimize away the
// temporary, but most modern compilers can do this. Performance tests with
// gcc3.3 indicate that this is a realistic expectation for modern
// compilers.
// - since matrix/vector multiplies cannot be done without temporary data,
// the "primary" functions are the global matrix/vector
// rowVecMult/colVecMult routines, rather than the member functions.

inline UT_Vector2       rowVecMult(const UT_Vector2 &v, 
                                   const UT_TMatrix2<float> &m);
inline UT_Vector2       colVecMult(const UT_TMatrix2<float> &m, 
                                   const UT_Vector2 &v);
// @}

inline fpreal           distance2d(const UT_Vector2 &v1, const UT_Vector2 &v2);

/// 2D Vector class.
class UT_API UT_Vector2 {
public:
    /// Default constructor.
    /// No data is initialized! Use it for extra speed.
    inline       UT_Vector2(void)
                 {
                    UT_ASSERT_COMPILETIME(sizeof(UT_Vector2) ==
                                          2 * sizeof(float));
                 }
    inline       UT_Vector2(fpreal vx, fpreal vy)
                 {
                    vec[0] = vx; vec[1] = vy;
                 }
    explicit     UT_Vector2(const fpreal32 v[2])
                 {
                    vec[0] = v[0]; vec[1] = v[1];
                 }
    explicit     UT_Vector2(const fpreal64 v[2])
                 {
                    vec[0] = v[0]; vec[1] = v[1];
                 }
    explicit     UT_Vector2(const UT_Vector3 &v);
    explicit     UT_Vector2(const UT_Vector4 &v);
    // Default copy constructor is fine.
    //           UT_Vector2(const UT_Vector2 &v);
                ~UT_Vector2(void)               {}

    // Default assignment operator is fine.
    //UT_Vector2&operator=(const UT_Vector2 &v);

    // TODO: remove these. They should require an explicit UT_Vector2()
    // construction, since they're unsafe.

    /// Assignment operator that truncates a V3 to a V2. 
    UT_Vector2  &operator=(const UT_Vector3 &v);
    /// Assignment operator that truncates a V4 to a V2. 
    UT_Vector2  &operator=(const UT_Vector4 &v);
    UT_Vector2  operator-() const
                {
                    return UT_Vector2(-vec[0], -vec[1]);
                }
    UT_Vector2  &operator+=(const UT_Vector2 &v)
                {
                    vec[0] += v.vec[0];
                    vec[1] += v.vec[1];
                    return *this;
                }
    UT_Vector2  &operator-=(const UT_Vector2 &v)
                {
                    vec[0] -= v.vec[0];
                    vec[1] -= v.vec[1];
                    return *this;
                }
    unsigned    operator==(const UT_Vector2 &v) const
                {
                    return (vec[0] == v.vec[0] && vec[1] == v.vec[1]); 
                }
    unsigned    operator!=(const UT_Vector2 &v) const { return !(*this == v); } 
    int         equalZero(fpreal tol = 0.00001f) const
                {
                    return (vec[0] >= -tol && vec[0] <= tol) &&
                           (vec[1] >= -tol && vec[1] <= tol);
                }
    int         isEqual(const UT_Vector2 &v, fpreal tol = 0.00001f) const
                {
                    return ((vec[0]>=v.vec[0]-tol) && (vec[0]<=v.vec[0]+tol) &&
                            (vec[1]>=v.vec[1]-tol) && (vec[1]<=v.vec[1]+tol));
                }

    void        negate() { operator=(operator-()); }

    void        multiplyComponents(const UT_Vector2 &v)
                {
                    vec[0] *= v.vec[0];
                    vec[1] *= v.vec[1];
                }

    /// Given an oriented line from e1 passing through e2, determine on which
    /// side of the line the point p lies.  Alternatively, determine in which
    /// half plane, positive or negative, the point lies.  If the segment
    /// degenerates to a point, then the point is always on it.
    // (Moret and Shapiro 1991)
    
    fpreal      whichSide(const UT_Vector2 &e1, const UT_Vector2 &e2) const
                { 
                    return (vec[0] - e1.vec[0]) * (e2.vec[1] - e1.vec[1]) -
                           (vec[1] - e1.vec[1]) * (e2.vec[0] - e1.vec[0]);
                }

    UT_Vector2  &operator=(fpreal scalar)
                {
                    vec[0] = vec[1] = scalar;
                    return *this;
                }
    UT_Vector2  &operator+=(fpreal scalar)
                {
                    vec[0] += scalar;
                    vec[1] += scalar;
                    return *this;
                }
    UT_Vector2  &operator-=(fpreal scalar)
                {
                    return operator+=(-scalar);
                }
    UT_Vector2  &operator*=(fpreal scalar)
                {
                    vec[0] *= scalar;
                    vec[1] *= scalar;
                    return *this;
                }
    UT_Vector2  &operator*=(const UT_Vector2 &v)
                 {
                    vec[0] *= v.vec[0];
                    vec[1] *= v.vec[1];
                    return *this;
                 }
    UT_Vector2  &operator/=(fpreal scalar)
                {
                    return operator*=( 1.0f/scalar );
                }
    UT_Vector2  &operator/=(const UT_Vector2 &v)
                 {
                    vec[0] /= v.vec[0];
                    vec[1] /= v.vec[1];
                    return *this;
                 }

    UT_Vector2  &operator*=(const UT_TMatrix2<float> &mat)
                 { return operator=(*this * mat); }

    inline
    fpreal       dot(const UT_Vector2 &v) const
                 {
                    return ::dot(*this, v);
                 }
    fpreal       normalize (void)
                 {
                    fpreal dn   = vec[0]*vec[0] + vec[1]*vec[1];
                    if (dn > FLT_MIN && dn != 1.0F)
                    {
                        dn = SYSsqrt(dn);
                        (*this) /= dn;
                    }

                    return dn;
                 }

    /// These allow you to find out what indices to use for different axes
    // @{
    int                 findMinAbsAxis() const
                        {
                            if (SYSabs(x()) < SYSabs(y()))
                                return 0;
                            else
                                return 1;
                        }
    int                 findMaxAbsAxis() const
                        {
                            if (SYSabs(x()) >= SYSabs(y()))
                                return 0;
                            else
                                return 1;
                        }
    // @}

    /// The vector length (not to be confused with the vector dimension).
    inline fpreal       length(void) const { return SYSsqrt(dot(*this)); }
    /// The vector length squared.
    inline fpreal       length2(void) const { return dot(*this); }

    /// Calculates the orthogonal projection of a vector u on the *this vector 
    UT_Vector2          project(const UT_Vector2 &u);


    /// Vector p (representing a point in 2-space) and vector v define
    /// a line. This member returns the projection of "this" onto the
    /// line (the point on the line that is closest to this point).
    UT_Vector2          projection(const UT_Vector2 &p, const UT_Vector2 &v) const;

    /// Compute (homogeneous) barycentric co-ordinates of this point
    /// relative to the triangle defined by t0, t1 and t2. (The point is
    /// projected into the triangle's plane.)
    UT_Vector3  getBary(const UT_Vector2 &t0, const UT_Vector2 &t1,
                        const UT_Vector2 &t2, bool *degen = NULL) const;


    /// Return the components of the vector. The () operator does NOT check
    /// for the boundary condition.
    // @{
    const float *data(void) const       { return &vec[0]; }
    float       &x(void)                { return vec[0]; } 
    float        x(void) const          { return vec[0]; } 
    float       &y(void)                { return vec[1]; } 
    float        y(void) const          { return vec[1]; } 
    float       &operator()(unsigned i)
                 {
                     UT_ASSERT_P(i < 2);
                     return vec[i];
                 }
    float        operator()(unsigned i) const
                 {
                     UT_ASSERT_P(i < 2);
                     return vec[i];
                 }
    float       &operator[](unsigned i)
                 {
                     UT_ASSERT_P(i < 2);
                     return vec[i];
                 }
    float        operator[](unsigned i) const
                 {
                     UT_ASSERT_P(i < 2);
                     return vec[i];
                 }
    // @}

    // TODO: eliminate these methods. They're redundant, given good inline
    // constructors.
    /// Set the values of the vector components
    void         assign(fpreal xx = 0.0f, fpreal yy = 0.0f)
                 {
                    vec[0] = xx; vec[1] = yy;
                 }
    /// Set the values of the vector components
    void         assign(const float *v) {vec[0]=v[0]; vec[1]=v[1];}

    /// Express the point in homogeneous coordinates or vice-versa
    // @{
    void         homogenize  (void)     { vec[0] *= vec[1]; }
    void         dehomogenize(void)     { vec[0] /= vec[1]; }
    // @}

    /// Protected I/O methods
    // @{
    void        save(ostream &os, int binary = 0) const;
    bool        load(UT_IStream &is);
    // @}

    /// The data.
    float vec[2];

private:
    /// I/O friends
    // @{
    friend ostream      &operator<<(ostream &os, const UT_Vector2 &v)
                        {
                            v.save(os);
                            return os;
                        }
    // @}
};

#include "UT_Matrix2.h"

// Free floating functions:
inline UT_Vector2       operator+(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return UT_Vector2(v1.x()+v2.x(), v1.y()+v2.y());
}
inline UT_Vector2       operator-(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return UT_Vector2(v1.x()-v2.x(), v1.y()-v2.y());
}
inline UT_Vector2       operator*(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return UT_Vector2(v1.x()*v2.x(), v1.y()*v2.y());
}
inline UT_Vector2       operator/(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return UT_Vector2(v1.x()/v2.x(), v1.y()/v2.y());
}
inline bool             operator<(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return ((v1.x() < v2.x()) || (v1.x() == v2.x() && v1.y() < v2.y()));
}
inline bool             operator<=(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return (v1 < v2) || (v1 == v2);
}
inline bool             operator>(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return v2 < v1;
}
inline bool             operator>=(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return v2 <= v1;
}
inline UT_Vector2       operator+(const UT_Vector2 &v, fpreal scalar)
{
    return UT_Vector2(v.x()+scalar, v.y()+scalar);
}
inline UT_Vector2       operator+(fpreal scalar, const UT_Vector2 &v)
{
    return UT_Vector2(v.x()+scalar, v.y()+scalar);
}
inline UT_Vector2       operator-(const UT_Vector2 &v, fpreal scalar)
{
    return UT_Vector2(v.x()-scalar, v.y()-scalar);
}
inline UT_Vector2       operator-(fpreal scalar, const UT_Vector2 &v)
{
    return UT_Vector2(scalar-v.x(), scalar-v.y());
}
inline UT_Vector2       operator*(const UT_Vector2 &v, fpreal scalar)
{
    return UT_Vector2(v.x()*scalar, v.y()*scalar);
}
inline UT_Vector2       operator*(fpreal scalar, const UT_Vector2 &v)
{
    return UT_Vector2(v.x()*scalar, v.y()*scalar);
}
inline UT_Vector2       operator/(const UT_Vector2 &v, fpreal scalar)
{
    return UT_Vector2(v.x()/scalar, v.y()/scalar);
}
inline UT_Vector2       operator/(fpreal scalar, const UT_Vector2 &v)
{
    return UT_Vector2(scalar/v.x(), scalar/v.y());
}
inline fpreal           dot(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return v1.x()*v2.x() + v1.y()*v2.y();
}
inline fpreal           cross(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return v1.x() * v2.y() - v1.y() * v2.x();
}
inline UT_Vector2       project(const UT_Vector2 &u, const UT_Vector2 &v)
{
    return dot(u, v) / v.length2() * v;
}
inline UT_Vector2       rowVecMult(const UT_Vector2 &v, const UT_Matrix2 &m)
{
    return UT_Vector2(v.x()*m(0,0) + v.y()*m(1,0),
                      v.x()*m(0,1) + v.y()*m(1,1));
}
inline UT_Vector2       colVecMult(const UT_Matrix2 &m, const UT_Vector2 &v)
{
    return UT_Vector2(m(0,0)*v.x() + m(0,1)*v.y(),
                      m(1,0)*v.x() + m(1,1)*v.y());
}
inline UT_Vector2       operator*(const UT_Vector2 &v, const UT_Matrix2 &m)
{
    return rowVecMult(v, m);
}
inline fpreal           distance2d(const UT_Vector2 &v1, const UT_Vector2 &v2)
{
    return (v1 - v2).length();
}

#endif

---