DtVdcVector2D.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2010 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
#pragma once

#include <vlutil/vlString.h>
#include <matrix/vlVector.h>
#include <iosfwd>

#include <vrvDrawControl/vrvDrawControl.h>

// \file DtVdcVector2D.h
// \brief DtVdcVector2D.h provides an implimentation of a 2D Vector class as well as 
// many methods which operate on DtVdcVector2Ds. 
namespace vrvControlToolkit
{

   enum DtVdcVector2DOffset
   {
      DtVdcX,
      DtVdcY
   };

   class DtVdcVector2D;

   typedef const DtVdcVector2D &DtVdcConstVector2D;
   typedef DtVdcVector2D &DtVdcVector2DRef;

   // \brief DtVdcVector2Ds represent vectors in 2-d space, X, Y
   // 
   // A DtVdcVector2D is the 2D equivalent of the 3D DtVector
   class DT_DLL_VRVDRAWCONTROL DtVdcVector2D
   {
   public:

      DtVdcVector2D();

      // Construct from two doubles.
      DtVdcVector2D( const double& x, const double& y );

      // destructor
      ~DtVdcVector2D();

      // copy constructor
      DtVdcVector2D(const DtVdcVector2D& vec);

      // assignment operator
      DtVdcVector2D& operator=(const DtVdcVector2D& vec);

      // set Vector to all zeros
      void setToZero();

      // @{
      // gets/sets the x component of a Vector
      const double& x() const;
      void setX(const double& x);
      // @}

      // @{
      // gets/sets the y component of a Vector
      const double& y() const;
      void setY(const double& y);
      // @}

      // adds other to this vector
      DtVdcVector2D &operator+=(const DtVdcVector2D &other);

      // subtracts other from this vector (this - other)
      DtVdcVector2D &operator-=(const DtVdcVector2D &other);

      // subtraction
      DtVdcVector2D operator-(const DtVdcVector2D &other) const;

      // addition
      DtVdcVector2D operator+(const DtVdcVector2D &other) const;

      // multiplies this vector by scalar
      DtVdcVector2D operator*(float scale) const;

      // multiplies this vector by scalar
      DtVdcVector2D& operator*=(float scale);

      // Get the value for the specified subscript.  (int version)
      double& operator[](int ind);

      // A const version to get the value for the specified subscript
      double operator[](int ind) const;

      // Get the value for the specified subscript. (enum version)
      double& operator[](DtVdcVector2DOffset ind);

      // a const version to get the value for the specified subscript. (enum version)
      double operator[](DtVdcVector2DOffset ind) const;

      // Get whether another vector equals this vector. Warning: This
      // operation compares floats of exact equality. 
      int operator==(const DtVdcVector2D& vec) const;

      // Get whether another vector does not equal this vector. Warning:
      // this operation calles operator== which tests floats for exact equality
      int operator!=(const DtVdcVector2D& vec) const;

      // Get a string representation of the vector.
      DtString string() const;

      // Create a DtVector (with z==0) from a DtVdcVector2D
      DtVector vector3D() const;

      // Get the magnitude of the vector squared,
      // i.e. x^2 + y^2
      double magnitudeSquared() const;

      // Normalize the vector; i.e., magnitude = 1.
      void normalize();

      // Returns true of the vector is Normalized
      bool isNormalized() const;

      // Compute dot product with another vector
      double dotProduct(const DtVdcVector2D& v) const;

      // check if the vector is zero-ed out withing the tolerace passed
      bool approxEq(const DtVdcVector2D& v, const double& tolerance) const;

      // check if the magnitide of this vector is zero
      bool magnitudeIsZero() const;

      // check if the magnitide of this vector is zero, within the tolerance passed.
      // \Note This tolerance is comparied against each component of the vector,
      // not the magnitude.
      bool magnitudeIsZero(double tolerance) const;

      // prints out a formated string to the stream
      std::ostream &printDataToStream(std::ostream &str) const;

   public:

      // @name These functions reveal the internal representation of DtVector
      // and should not be used. They are provided for backwards compatability
      // @{
      operator double* ();
      operator const double* () const;
      // @}

   public:


      // Get a zero'ed vector.
      static const DtVdcVector2D& zero();

      // Get a (1,0) vector.
      static const DtVdcVector2D& i();

      // Get a (0,1) vector.
      static const DtVdcVector2D& j();

      // Get a vector set to all ones.
      static const DtVdcVector2D& ones();


   protected:

      double myRep[2];


   };

   //
   // Vector routines.
   //

#define DtSetVec2D(v, x, y)    v[DtSdcX]=x;v[DtSdcY]=y;

   DT_DLL_VRVDRAWCONTROL void      DtVecScale(const DtVdcVector2D& v, double scale_factor, DtVdcVector2D& result);
   DT_DLL_VRVDRAWCONTROL void      DtVecNeg(const DtVdcVector2D& v1, DtVdcVector2D& result); // result = -vec 

   // cos of angle between v1 and V2 
   DT_DLL_VRVDRAWCONTROL double    DtVecCosProd(const DtVdcVector2D& v1, const DtVdcVector2D& v2);

   DT_DLL_VRVDRAWCONTROL double    DtVecInfNorm(const DtVdcVector2D& v1);
   DT_DLL_VRVDRAWCONTROL void      DtVecInit(DtVdcVector2D& v); // Initialize to all zeros. 

   /* ||p1-p2||_{2} */
   DT_DLL_VRVDRAWCONTROL double DtDistance(const DtVdcVector2D& p1, const DtVdcVector2D& p2);  

   DT_DLL_VRVDRAWCONTROL double DtDistSqr(const DtVdcVector2D& p1, const DtVdcVector2D& p2);
}

std::ostream & operator << (std::ostream &str, const vrvControlToolkit::DtVdcVector2D &vec);


// Include inline definitions for vlVector
#define DtVdcVector2D_inl
#include <vrvDrawControl/DtVdcVector2D.inl>
#undef DtVdcVector2D_inl