MeVis/Foundation/Sources/MLLinearAlgebra/mlVector3.h

Go to the documentation of this file.

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

//=====================================================================================
#ifndef __mlVector3_H
#define __mlVector3_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
#ifndef __mlVector2_H
#include "mlVector2.h"
#endif


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

template <class DT>
class Vector3DataContainer
{
public:
  union {
    struct {
      DT x;
      DT y;
      DT z;
    };
    DT _buffer[3];
  };
};

//--------------------------------------------------------------------
// 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 Tvec4;
template <class DT> class Tmat3;
template <class DT> class Tmat4;

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT>
class Tvec3 : public FloatingPointVector<DT, 3, Vector3DataContainer<DT> >
{

public:

  typedef FloatingPointVector<DT, 3, Vector3DataContainer<DT> > Superclass;

  typedef DT ComponentType;

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

  //--------------------------------------------------------------------
  inline explicit Tvec3(const DT value=0) : FloatingPointVector<DT, 3, Vector3DataContainer<DT> >(value)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec3::Tvec3(const DT value=0)");
  }

  inline Tvec3(const Superclass &v) : Superclass(v)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec3::Tvec3(const FloatingPointVector<DT, 3, Vector3DataContainer<DT> >& v)");
  }

  inline Tvec3(const DT px, const DT py, const DT pz)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec3::Tvec3(const DT px, const DT py, const DT pz)");

    Superclass::_buffer[0] = px;
    Superclass::_buffer[1] = py;
    Superclass::_buffer[2] = pz;
  };

  inline Tvec3(const Tvec2<DT>& v, const DT pz)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec3::Tvec3(const Tvec2<DT>& v, const DT z)");

    Superclass::_buffer[0] = v[0];
    Superclass::_buffer[1] = v[1];
    Superclass::_buffer[2] = pz;
  };

  Tvec3(const Tvec4<DT>& v, const bool normalizeV)
  {
    ML_TRACE_IN("Tvec3::Tvec3(const Tvec4<DT>& v, const bool normalizeV)");

    ML_TRY
    {
      if (normalizeV){
        // Homogeneous cast.
        if (MLValuesDifferWOM(v[3], static_cast<DT>(0))){
          DT divi = 1.0/v[3];
          Superclass::_buffer[0] = v[0]*divi;
          Superclass::_buffer[1] = v[1]*divi;
          Superclass::_buffer[2] = v[2]*divi;
        }
        else{
          // This must/should not occur.
          ML_PRINT_ERROR("Tvec3::Tvec3(const Tvec4<DT>& v, const bool normalizeV)",
                         ML_BAD_PARAMETER,
                         "Normalization with zero fourth component of homogeneous vector "
                         "performed. Leaving vector unchanged.");
        }
      }
      else{
        // Normal cast.
        Superclass::_buffer[0] = v[0];
        Superclass::_buffer[1] = v[1];
        Superclass::_buffer[2] = v[2];
      }
    }
    ML_CATCH_RETHROW;
  }

  Tvec3(const Tvec4<DT>& v, const int axis)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec3::Tvec3(const Tvec4<DT>& v, const int axis)");

    switch (axis) {
      case  0:
        Superclass::_buffer[0] = v[1];
        Superclass::_buffer[1] = v[2];
        Superclass::_buffer[2] = v[3];
        break;
      case  1:
        Superclass::_buffer[0] = v[0];
        Superclass::_buffer[1] = v[2];
        Superclass::_buffer[2] = v[3];
        break;
      case  2:
        Superclass::_buffer[0] = v[0];
        Superclass::_buffer[1] = v[1];
        Superclass::_buffer[2] = v[3];
        break;
      default:
        Superclass::_buffer[0] = v[0];
        Superclass::_buffer[1] = v[1];
        Superclass::_buffer[2] = v[2];
        break;
    }
  }

  inline void assign(const DT px, const DT py, const DT pz)
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec3::assign(const DT px, const DT py, const DT pz)");

    Superclass::_buffer[0] = px;
    Superclass::_buffer[1] = py;
    Superclass::_buffer[2] = pz;
  }

  inline Tvec3<DT> divideByLastComp() const
  {
    ML_TRACE_IN( "Tvec3<DT>::divideByLastComp() const( )" );

    Tvec3<DT> retVal;
    ML_TRY
    {

      const DT lastComp = Superclass::_buffer[2];
      ML_CHECK_FLOAT(lastComp);

      const DT div = static_cast<DT>(1) / lastComp;

      retVal = Tvec3(Superclass::_buffer[0] * div,
                     Superclass::_buffer[1] * div,
                     1);
    }
    ML_CATCH_RETHROW;
    return retVal;
  }

  inline Tvec4<DT> affineVec() const
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec3::affineVec() const");

    return Tvec4<DT>(*this, 0);
  }

  inline Tvec4<DT> affinePoint() const
  {
    ML_TRACE_IN_TIME_CRITICAL("Tvec3::affinePoint() const");

    return Tvec4<DT>(*this, 1);
  }

#ifdef ML_DEPRECATED




  inline ML_DEPRECATED void Set(const DT px, const DT py, const DT pz)
  {
    ML_TRACE_IN_TIME_CRITICAL("Set(const DT px, const DT py, const DT pz)");

    assign(px, py, pz);
  }
#endif


}; // end of class *Tvec3*


//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT, class DT2>
inline Tvec3<DT> operator*(const Tmat3<DT>& a, const Tvec3<DT2>& v)
{
  ML_TRACE_IN_TIME_CRITICAL("mlVector3.h: operator*(const Tmat3<DT>& a, const Tvec3<DT2>& v)");

  return Tvec3<DT>(a[0][0]*v[0] + a[0][1]*v[1] + a[0][2]*v[2],
                   a[1][0]*v[0] + a[1][1]*v[1] + a[1][2]*v[2],
                   a[2][0]*v[0] + a[2][1]*v[1] + a[2][2]*v[2]);
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT, class DT2>
inline Tvec3<DT> operator*(const Tvec3<DT>& v, const Tmat3<DT2>& a)
{
  ML_TRACE_IN_TIME_CRITICAL("mlVector3.h: operator*(const Tvec3<DT>& v, const Tmat3<DT2>& a)");

  return a.transpose() * v;
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT, class DT2>
inline Tvec3<DT> operator*(const Tmat4<DT>& a, const Tvec3<DT2>& v)
{
  ML_TRACE_IN_TIME_CRITICAL("mlVector3.h: operator*(const Tmat4<DT>& a, const Tvec3<DT2>& v)");

  // Normalize homogeneous 4d result to Tvec3 by dividing by the fourth component.
  return Tvec3<DT>(a * v.affinePoint(), true);
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT, class DT2>
inline Tvec3<DT> operator*(const Tvec3<DT>& v, const Tmat4<DT2>& a)
{
  ML_TRACE_IN_TIME_CRITICAL("mlVector3.h: operator*(const Tvec3<DT>& v, const Tmat4<DT2>& a)");

  // Note: This uses homogeneous "operator*(const Tmat4<DT>& a, const Tvec3<DT2>& v)"
  // implemented above.
  return a.transpose() * v;
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class DT, class DT2>
inline Tvec3<DT> operator^(const Tvec3<DT>& a, const Tvec3<DT2>& b)
{
  ML_TRACE_IN_TIME_CRITICAL("mlVector3.h: operator^(const Tvec3<DT> &a, const Tvec3<DT2> &b)");

  return Tvec3<DT>(a[1]*b[2] - a[2]*b[1],
                   a[2]*b[0] - a[0]*b[2],
                   a[0]*b[1] - a[1]*b[0]);
}

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

//-----------------------------------------------------------------------------------
typedef Tvec3<MLfloat>   Vector3f;
typedef Tvec3<MLdouble>  Vector3d;
typedef Tvec3<MLldouble> Vector3ld;
typedef Tvec3<MLdouble>  Vector3;


#ifdef ML_DEPRECATED




ML_DEPRECATED typedef Tvec3<MLfloat>   vecf3;
ML_DEPRECATED typedef Tvec3<MLdouble>  vecd3;
ML_DEPRECATED typedef Tvec3<MLldouble> vecld3;
ML_DEPRECATED typedef Tvec3<MLdouble> vec3;

#endif // ML_DEPRECATED


ML_LA_END_NAMESPACE

#endif //of __mlVector3_H