MeVis/Foundation/Sources/MLLinearAlgebra/mlVector2.h

Go to the documentation of this file.

// **InsertLicense** code 
//=====================================================================================

//=====================================================================================
#ifndef __mlVector2_H
#define __mlVector2_H

// Include system independency file and project settings.
#ifndef __mlLinearAlgebraSystem_H
#include "mlLinearAlgebraSystem.h"
#endif
#ifndef __mlLinearAlgebraDefs_H
#include "mlLinearAlgebraDefs.h"
#endif
#ifndef __mlFloatingPointVector_H
#include "mlFloatingPointVector.h"
#endif

// All declarations of this header will be in the ML_LA_NAMESPACE namespace.
ML_LA_START_NAMESPACE

template <class DT>
class Vector2DataContainer
{
public:
  union {
    struct {
      DT x; 
      DT y;
    };
    DT _buffer[2];
  };
};

//--------------------------------------------------------------------
// This is necessary because we do not known whether vector or 
// matrix header is included first and we cannot move template
// code into C++ file.
//--------------------------------------------------------------------
template <class DT> class Tvec3;

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
class Tvec2 : public FloatingPointVector<DT, 2, Vector2DataContainer<DT> > {
public:
  
  typedef FloatingPointVector<DT, 2, Vector2DataContainer<DT> > Superclass;

  typedef DT ComponentType;
  
  //--------------------------------------------------------------------

  //--------------------------------------------------------------------
  inline explicit Tvec2(const DT value=0) : Superclass(value)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec2::Tvec2(DT value=0)");
  }
  
  inline Tvec2(const Superclass &v): Superclass(v)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec2::Tvec2(const FloatingPointVector<DT, 2, Vector2DataContainer<DT> >& v)");
  }
  
  inline Tvec2(const DT px, const DT py) : Superclass()
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec2::Tvec2(DT px, DT py)");
    
    assign(px,py);
  }
  
  inline void assign(const DT px, const DT py)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec2::assign(const DT x, const DT y)");
    
    Superclass::_buffer[0] = px;
    Superclass::_buffer[1] = py;
  }
  
  inline Tvec2(const Tvec3<DT>& v, const bool normalize) : Superclass()
  {
    ML_TRACE_IN("Tvec2::Tvec2(const Tvec2<DT>& v, const bool normalize)");
    ML_TRY
    {
      if (normalize){
        // Homogeneous cast.
        ML_CHECK_FLOAT_THROW(v[2]);
        Superclass::_buffer[0] = v[0]/v[2];
        Superclass::_buffer[1] = v[1]/v[2];
      }
      else{
        // Normal cast.
        Superclass::_buffer[0] = v[0];
        Superclass::_buffer[1] = v[1];
      }
    }
    ML_CATCH_RETHROW;
  }
  
  inline Tvec2(const Tvec3<DT>& v, const int axis) : Superclass()
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec2::Tvec2(const Tvec3<DT>& v, const int axis)");
    
    switch (axis) {
      case 0:  Superclass::_buffer[0] = v[1];
               Superclass::_buffer[1] = v[2]; break;
      case 1:  Superclass::_buffer[0] = v[0];
               Superclass::_buffer[1] = v[2]; break;
      default: Superclass::_buffer[0] = v[0];
               Superclass::_buffer[1] = v[1]; break;
    }
  }
  
  inline Tvec3<DT> affineVec() const
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec2::affineVec() const");
    
    return Tvec3<DT>(*this, 0);
  }
  
  inline Tvec3<DT> affinePoint() const
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec2::affinePoint() const");
    
    return Tvec3<DT>(*this, 1);
  }
  
}; // end of class *Tvec2<DT>*


//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------
typedef Tvec2<MLfloat>   Vector2f;
typedef Tvec2<MLdouble>  Vector2d;
typedef Tvec2<MLldouble> Vector2ld;
typedef Tvec2<MLdouble>  Vector2;


#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Tvec2<MLfloat>   vecf2;
ML_DEPRECATED typedef Tvec2<MLdouble>  vecd2;
ML_DEPRECATED typedef Tvec2<MLldouble> vecld2;
ML_DEPRECATED typedef Tvec2<MLdouble> vec2;

#endif // ML_DEPRECATED


ML_LA_END_NAMESPACE

#endif //of __mlVector2_H