mlImageVector.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2010, 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_IMAGE_VECTOR_H
#define ML_IMAGE_VECTOR_H
 
 
// ML-includes
#include "mlIntegerVector.h"
 
 
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; }
 
    // Propagates constructors and sets 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){}
 
 
    // Adds specialized constructors and functionality.
    inline TImageVector(const ComponentType xp, const ComponentType yp, const ComponentType zp,
                        const ComponentType cp, const ComponentType tp, const ComponentType up)
    {
      ParentClass::x = xp;
      ParentClass::y = yp;
      ParentClass::z = zp;
      ParentClass::c = cp;
      ParentClass::t = tp;
      ParentClass::u = up;
    }
 
    inline explicit 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)
    {
      ParentClass::x = vx;
      ParentClass::y = vy;
      ParentClass::z = vz;
      ParentClass::c = vc;
      ParentClass::t = vt;
      ParentClass::u = vu;
    }
 
    inline void get(ComponentType * const xp= nullptr, ComponentType * const yp= nullptr, ComponentType * const zp= nullptr,
                    ComponentType * const cp= nullptr, ComponentType * const tp= nullptr, ComponentType * const up= nullptr) const
    {
      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; }
    }
 
    inline bool 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
    {
      return Vector6(static_cast<double>(ParentClass::x),
                     static_cast<double>(ParentClass::y),
                     static_cast<double>(ParentClass::z),
                     static_cast<double>(ParentClass::c),
                     static_cast<double>(ParentClass::t),
                     static_cast<double>(ParentClass::u));
    }
 
    inline Vector3 toVector3() const
    {
      return Vector3(static_cast<double>(ParentClass::x),
        static_cast<double>(ParentClass::y),
        static_cast<double>(ParentClass::z));
    }
 
  };
 
  typedef TImageVector<MLint> ImageVector;
 
ML_END_NAMESPACE
 
#endif