MeVis/Foundation/Sources/MLLinearAlgebra/mlImageVector.h

Go to the documentation of this file.

// **InsertLicense** code 
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
#ifndef __mlImageVector_H
#define __mlImageVector_H

// ML-includes
#ifndef __mlIntegerVector_H
#include "mlIntegerVector.h"
#endif


ML_START_NAMESPACE

  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  enum { MLMaxImageDimension = 6 };

  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  template <typename CompIntType> 
  class TVector6DBase 
  {
    public:

    typedef CompIntType ComponentType;

    enum { NumberOfDimensions = MLMaxImageDimension };

    // We use a union to make the vector members accessible
    // either with .x, ... .z or with .array[0..MLMaxImageDimension-1].
    // Below we also provide indexing operators [] on the array.
    union {
      //------------------------------------------------------

      //------------------------------------------------------
      struct {
        ComponentType x;
        ComponentType y;
        ComponentType z;
        ComponentType c;
        ComponentType t;
        ComponentType u;
      };
      
      ComponentType array[NumberOfDimensions];
    };

    protected:
    
    TVector6DBase(){};

  };


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

  //-------------------------------------------------------------------------
  template <typename CompIntType=MLint> 
  class TImageVector : public TVector<TVector6DBase<CompIntType> > {
    public:

    typedef TVector<TVector6DBase<CompIntType> > ParentClass;

    typedef typename ParentClass::ComponentType  ComponentType;

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

    //------------------------------------------------------
    inline static MLint dim(){ return MLMaxImageDimension; }

    // Propagate constructors and set shadowed methods from base class.
    inline TImageVector() : ParentClass(){ }
  
    inline TImageVector(const ParentClass& v) : ParentClass(v){ }
  
    inline explicit TImageVector(const ComponentType i) : ParentClass(i){ }
  
    template <typename T2IntType>
    inline explicit TImageVector(const TImageVector<T2IntType> &v2) : ParentClass(v2){}
    
    inline TImageVector(const ComponentType xp, const TImageVector<ComponentType> &p) : ParentClass(xp, p){ }

    inline void set(const ComponentType v=0){ ParentClass::set(v); }

    inline void set(const ParentClass &v){ ParentClass::set(v); }

    inline TImageVector(const MLint num, const ComponentType* const arr, const ComponentType deflt) : ParentClass(num, arr, deflt){}
    

    // Add specialized constructors and functionality.
    inline TImageVector(const ComponentType xp, const ComponentType yp, const ComponentType zp, 
                        const ComponentType cp, const ComponentType tp, const ComponentType up)
    {
      ML_TRACE_IN_TIME_CRITICAL( "TImageVector(6 args)" );
      ParentClass::x = xp; 
      ParentClass::y = yp; 
      ParentClass::z = zp;
      ParentClass::c = cp; 
      ParentClass::t = tp; 
      ParentClass::u = up; 
    }

    inline explicit TImageVector(const Vector6 &v6)
    {
      ML_TRACE_IN_TIME_CRITICAL( "TImageVector(const Vector6 &v6)" );
      ParentClass::x = static_cast<ComponentType>(v6[0]); 
      ParentClass::y = static_cast<ComponentType>(v6[1]); 
      ParentClass::z = static_cast<ComponentType>(v6[2]);
      ParentClass::c = static_cast<ComponentType>(v6[3]); 
      ParentClass::t = static_cast<ComponentType>(v6[4]); 
      ParentClass::u = static_cast<ComponentType>(v6[5]); 
    }

    inline void set(const ComponentType vx  , const ComponentType vy  , const ComponentType vz=0, 
                    const ComponentType vc=0, const ComponentType vt=0, const ComponentType vu=0) 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TImageVector::set(6 args)" );
      ParentClass::x = vx; 
      ParentClass::y = vy; 
      ParentClass::z = vz; 
      ParentClass::c = vc; 
      ParentClass::t = vt; 
      ParentClass::u = vu;
    }

    inline void get(ComponentType * const xp=NULL, ComponentType * const yp=NULL, ComponentType * const zp=NULL, 
                    ComponentType * const cp=NULL, ComponentType * const tp=NULL, ComponentType * const up=NULL) const
    {
      ML_TRACE_IN_TIME_CRITICAL("TImageVector::get(...)");
      ML_TRY
      {
        if (xp){ *xp = ParentClass::x; }
        if (yp){ *yp = ParentClass::y; }
        if (zp){ *zp = ParentClass::z; }
        if (cp){ *cp = ParentClass::c; } 
        if (tp){ *tp = ParentClass::t; }
        if (up){ *up = ParentClass::u; }
      }
      ML_CATCH_RETHROW;
    }

    inline bool iterate(const TImageVector<ComponentType> &ext)
    {
      ML_TRACE_IN_TIME_CRITICAL("TImageVector::iterate(const TImageVector<ComponentType> &ext)");
      ParentClass::x++;
      if (ParentClass::x >= ext.x){
        ParentClass::x = 0; ParentClass::y++; 
        if (ParentClass::y >= ext.y){
          ParentClass::y = 0; ParentClass::z++; 
          if (ParentClass::z >= ext.z){
            ParentClass::z = 0; ParentClass::c++; 
            if (ParentClass::c >= ext.c){
              ParentClass::c = 0; ParentClass::t++; 
              if (ParentClass::t >= ext.t){
                ParentClass::t = 0; ParentClass::u++; 
                if (ParentClass::u >= ext.u){ 
                  ParentClass::u = 0; return true; 
                }
              }
            }
          }
        }
      }
      return false;
    }
  
    inline Vector6 toVector6() const 
    { 
      ML_TRACE_IN_TIME_CRITICAL("TImageVector::toVector6()");
      return Vector6(ParentClass::x,
                     ParentClass::y,
                     ParentClass::z,
                     ParentClass::c,
                     ParentClass::t,
                     ParentClass::u);
    }

#ifdef ML_DEPRECATED




  inline ML_DEPRECATED Vector6 getVec6() const
  { 
    ML_TRACE_IN_TIME_CRITICAL("TImageVector::getVec6()");
    return toVector6(); 
  }

#endif // ML_DEPRECATED


  };

  ML_LINEAR_ALGEBRA_EXPORT typedef TImageVector<MLint> ImageVector;


#ifdef ML_DEPRECATED




  ML_LINEAR_ALGEBRA_EXPORT ML_DEPRECATED typedef ImageVector Vector;

#endif // ML_DEPRECATED

ML_END_NAMESPACE

#endif //of __mlImageVector_H