mlVector5.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_VECTOR5_H
#define ML_VECTOR5_H
 
 
// Include system independent file and project settings.
#include "mlLinearAlgebraSystem.h"
#include "mlLinearAlgebraDefs.h"
#include "mlFloatingPointVector.h"
#include "mlVector2.h"
#include "mlVector3.h"
#include "mlVector4.h"
#include "mlMatrix5.h"
 
// All declarations of this header will be in the ML_LINEAR_ALGEBRA namespace.
ML_LA_START_NAMESPACE
 
//--------------------------------------------------------------------
// 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 Tvec2;
template <class DT> class Tvec3;
template <class DT> class Tvec4;
template <class DT> class Tmat5;
 
//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
class Tvec5 : public FloatingPointVector<DT,5>
{
public:
 
  typedef FloatingPointVector<DT,5> Superclass;
 
  typedef DT ComponentType;
 
  //--------------------------------------------------------------------
  //--------------------------------------------------------------------
  inline explicit Tvec5(const DT value=0) : Superclass(value)
  {
  }
 
  inline Tvec5(const Superclass &v) : Superclass(v)
  {
  }
 
  inline Tvec5(const DT x, const DT y, const DT z, const DT c, const DT t)
  {
    Superclass::_buffer[0] = x;
    Superclass::_buffer[1] = y;
    Superclass::_buffer[2] = z;
    Superclass::_buffer[3] = c;
    Superclass::_buffer[4] = t;
  }
 
  inline Tvec5(const Tvec2<DT>& v, const DT z, const DT c, const DT t)
  {
    Superclass::_buffer[0] = v[0];
    Superclass::_buffer[1] = v[1];
    Superclass::_buffer[2] = z;
    Superclass::_buffer[3] = c;
    Superclass::_buffer[4] = t;
  }
 
  inline Tvec5(const Tvec3<DT>& v, const DT c, const DT t)
  {
    Superclass::_buffer[0] = v[0];
    Superclass::_buffer[1] = v[1];
    Superclass::_buffer[2] = v[2];
    Superclass::_buffer[3] = c;
    Superclass::_buffer[4] = t;
  }
 
  inline Tvec5(const Tvec4<DT>& v, const DT t)
  {
    Superclass::_buffer[0] = v[0];
    Superclass::_buffer[1] = v[1];
    Superclass::_buffer[2] = v[2];
    Superclass::_buffer[3] = v[3];
    Superclass::_buffer[4] = t;
  }
 
  //--------------------------------------------------------------------
  //--------------------------------------------------------------------
  inline void assign(const DT x, const DT y, const DT z, const DT c, const DT t)
  {
    Superclass::_buffer[0] = x;
    Superclass::_buffer[1] = y;
    Superclass::_buffer[2] = z;
    Superclass::_buffer[3] = c;
    Superclass::_buffer[4] = t;
  }
 
  inline Tvec5<DT>& operator+=(const Tvec2<DT>& v)
  {
    Superclass::_buffer[0] += v[0];
    Superclass::_buffer[1] += v[1];
    return *this;
  }
 
  inline Tvec5<DT>& operator+=(const Tvec3<DT>& v)
  {
    Superclass::_buffer[0] += v[0];
    Superclass::_buffer[1] += v[1];
    Superclass::_buffer[2] += v[2];
    return *this;
  }
 
  inline Tvec5<DT>& operator+=(const Tvec4<DT>& v)
  {
    Superclass::_buffer[0] += v[0];
    Superclass::_buffer[1] += v[1];
    Superclass::_buffer[2] += v[2];
    Superclass::_buffer[3] += v[3];
    return *this;
  }
 
  inline const Tvec3<DT> getVec3() const
  {
    return Tvec3<DT>(Superclass::_buffer[0],
                     Superclass::_buffer[1],
                     Superclass::_buffer[2]);
  }
 
  inline const Tvec4<DT> getVec4() const
  {
    return Tvec4<DT>(Superclass::_buffer[0],
                     Superclass::_buffer[1],
                     Superclass::_buffer[2],
                     Superclass::_buffer[3]);
  }
};
 
#define _ML_VEC5_RC(i) a[i][0]*v[0] + a[i][1]*v[1] + a[i][2]*v[2] + a[i][3]*v[3] + a[i][4]*v[4]
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class DT>
inline Tvec5<DT> operator*(const Tmat5<DT>& a, const Tvec5<DT>& v)
{
  return Tvec5<DT>(_ML_VEC5_RC(0), _ML_VEC5_RC(1), _ML_VEC5_RC(2), _ML_VEC5_RC(3), _ML_VEC5_RC(4));
}
#undef _ML_VEC5_RC
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class DT>
inline Tvec5<DT> operator*(const Tvec5<DT>& v, const Tmat5<DT>& a)
{
  return a.transpose() * v;
}
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
typedef Tvec5<MLfloat>   Vector5f;
typedef Tvec5<MLdouble>  Vector5d;
typedef Tvec5<MLldouble> Vector5ld;
typedef Tvec5<MLdouble>  Vector5;
 
 
#if ML_DEPRECATED_SINCE(3,5,0)
ML_DEPRECATED typedef Tvec5<MLfloat>   vecf5;
ML_DEPRECATED typedef Tvec5<MLdouble>  vecd5;
ML_DEPRECATED typedef Tvec5<MLldouble> vecld5;
ML_DEPRECATED typedef Tvec5<MLdouble> vec5;
 
#endif
 
 
ML_LA_END_NAMESPACE
 
#endif //of __mlVector5_H