MeVis/Foundation/Sources/ML/include/mlTSubImage.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
#ifndef __mlTSubImage_H
#define __mlTSubImage_H

// ML-includes
#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif
#ifndef __mlSubImage_H
#include "mlSubImage.h"
#endif
#ifndef __mlTypeTraits_H
#include "mlTypeTraits.h"
#endif

#include "mlTemplateSupport.h"

#ifdef _MSC_VER
#pragma warning(push)
// warning C4244: 'Argument': Konvertierung von 'typ1' in 'typ2', möglicher Datenverlust
#pragma warning(disable: 4244)
// warning C4127: Bedingter Ausdruck ist konstant
#pragma warning(disable: 4127)
#endif

ML_START_NAMESPACE




template <typename DATATYPE> class TSubImageCursor;
template <typename DATATYPE> class ConstTSubImageCursor;

#ifdef ML_IS_64_BIT_SYSTEM

#define _ML_TSUBIMG_SUBDOT6(pos, offset, stride) \
  (((pos).x - (offset).x) * (stride).x + \
   ((pos).y - (offset).y) * (stride).y + \
   ((pos).z - (offset).z) * (stride).z + \
   ((pos).c - (offset).c) * (stride).c + \
   ((pos).t - (offset).t) * (stride).t + \
   ((pos).u - (offset).u) * (stride).u)

#define _ML_TSUBIMG_SUBDOT3(x, y, z, offset, stride) \
  (((x) - (offset).x) * (stride).x + \
   ((y) - (offset).y) * (stride).y + \
   ((z) - (offset).z) * (stride).z)

#define _ML_TSUBIMG_SUBDOT2(x, y, offset, stride) \
  (((x) - (offset).x) * (stride).x + \
   ((y) - (offset).y) * (stride).y)

#else

#define _ML_TSUBIMG_SUBDOT6(pos, offset, stride) \
  (static_cast<MLint32>((pos).x - (offset).x) * static_cast<MLint32>((stride).x) + \
   static_cast<MLint32>((pos).y - (offset).y) * static_cast<MLint32>((stride).y) + \
   static_cast<MLint32>((pos).z - (offset).z) * static_cast<MLint32>((stride).z) + \
   static_cast<MLint32>((pos).c - (offset).c) * static_cast<MLint32>((stride).c) + \
   static_cast<MLint32>((pos).t - (offset).t) * static_cast<MLint32>((stride).t) + \
   static_cast<MLint32>((pos).u - (offset).u) * static_cast<MLint32>((stride).u))

#define _ML_TSUBIMG_SUBDOT3(x, y, z, offset, stride) \
  (static_cast<MLint32>((x) - (offset).x) * static_cast<MLint32>((stride).x) + \
   static_cast<MLint32>((y) - (offset).y) * static_cast<MLint32>((stride).y) + \
   static_cast<MLint32>((z) - (offset).z) * static_cast<MLint32>((stride).z))

#define _ML_TSUBIMG_SUBDOT2(x, y, offset, stride) \
  (static_cast<MLint32>((x) - (offset).x) * static_cast<MLint32>((stride).x) + \
   static_cast<MLint32>((y) - (offset).y) * static_cast<MLint32>((stride).y))

#endif

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
template <typename DATATYPE>
class TSubImage : public SubImage 
{

public:

  typedef TSubImageCursor<DATATYPE>      Cursor;
  typedef ConstTSubImageCursor<DATATYPE> ConstCursor;

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

  //---------------------------------------------------------------------------
  TSubImage(const SubImageBox& box, MLDataType dataType, void* data):SubImage(box, dataType, data)
  {
    ML_TRACE_IN( "TSubImage( )" );
    ML_TRY
    {
      // Check whether template type and real data type match if there is valid data.
      if (data && !TypeTraits<DATATYPE>::matches(dataType) )
      {
        ML_PRINT_FATAL_ERROR("TSubImage::TSubImage()", ML_BAD_DATA_TYPE,
          "Mismatch of data type between argument and template typename.");
      }
    }
    ML_CATCH_RETHROW;
  }

  TSubImage()
  {
    ML_TRACE_IN( "TSubImage()" );
    ML_TRY
    {
      // Set correct data type enum from template datatype.
      setDataType(TypeTraits<DATATYPE>::dataType);
      if (TypeTraits<DATATYPE>::dataType == ML_INVALID_DATA_TYPE) {
        ML_PRINT_FATAL_ERROR("TSubImage::TSubImage()", ML_BAD_DATA_TYPE,
          "Data type has no registered TypeTraits.");
      }
    }
    ML_CATCH_RETHROW;
  }


  TSubImage(const SubImage &subImage)
  {
    ML_TRACE_IN( "TSubImage( )" );
    ML_TRY
    {
      // Set box the data is correlated with.
      setBox(subImage.getBox());

      // Set correct data type enum.
      setDataType(subImage.getDataType());

      // Store data pointer (but NOT the memory block handle)
      setData(subImage.getData());

      // Set the source image extent
      setSourceImageExtent(subImage.getSourceImageExtent());

      // Check whether template type and real data type match if there is valid data.
      // This check only works if TypeTraits has been specified for the argument type. 
      if (subImage.getData() && !TypeTraits<DATATYPE>::matches(subImage.getDataType()) )
      {
        ML_PRINT_FATAL_ERROR("TSubImage::TSubImage()", ML_BAD_DATA_TYPE,
          "Mismatch of data type between argument and template typename.");
      }
    }
    ML_CATCH_RETHROW;
  }

  inline TSubImage(const TSubImage<DATATYPE>& typedSubImage) :
    SubImage       (typedSubImage)
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImage( )" );
  }

  inline virtual ~TSubImage(){ ML_TRACE_IN_TIME_CRITICAL("TSubImage::~TSubImage()"); }

  inline TSubImage &operator=(const TSubImage<DATATYPE>& typedSubImage)
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImage::operator=( )" );
    ML_TRY
    {
      SubImage::operator=(typedSubImage);
      return *this;
    }
    ML_CATCH_RETHROW;
  }

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

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

  inline const DATATYPE* getData()    const { return static_cast<DATATYPE*>(_data); }
  inline       DATATYPE* getData()          { return static_cast<DATATYPE*>(_data); }


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

  //---------------------------------------------------------------------------
  // 64 bit arithmetic is not needed here, because the pointer offset goes from the valid
  // address space to another position inside the valid address space. We do not
  // fall outside 32 bit ranges.
  inline const DATATYPE* getSubImagePointer(const ImageVector& position) const { return static_cast<DATATYPE*>(_data) + ImageVector::dot(position,_stride); }
  inline       DATATYPE* getSubImagePointer(const ImageVector& position)       { return static_cast<DATATYPE*>(_data) + ImageVector::dot(position,_stride); }
  
  // 64 bit arithmetic is not needed here, because the pointer offset goes from the valid
  // address space to another position inside the valid address space. We do not
  // fall outside 32 bit ranges.
  inline const DATATYPE* getSubImagePointer(MLint x, MLint y, MLint z) const { return static_cast<DATATYPE*>(_data) + (x*_stride.x + y*_stride.y + _stride.z*z); }
  inline       DATATYPE* getSubImagePointer(MLint x, MLint y, MLint z)       { return static_cast<DATATYPE*>(_data) + (x*_stride.x + y*_stride.y + _stride.z*z); }
  

  inline const DATATYPE* getImagePointer(const ImageVector& position) const { return static_cast<DATATYPE*>(_data) + _ML_TSUBIMG_SUBDOT6(position, _box.v1, _stride); }
  inline       DATATYPE* getImagePointer(const ImageVector& position)       { return static_cast<DATATYPE*>(_data) + _ML_TSUBIMG_SUBDOT6(position, _box.v1, _stride); }
  

  inline const DATATYPE* getImagePointer(MLint x, MLint y, MLint z) const { return static_cast<DATATYPE*>(_data) + _ML_TSUBIMG_SUBDOT3(x,y,z, _box.v1, _stride); }
  inline       DATATYPE* getImagePointer(MLint x, MLint y, MLint z)       { return static_cast<DATATYPE*>(_data) + _ML_TSUBIMG_SUBDOT3(x,y,z, _box.v1, _stride); }



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

  //-------------------------------------------------------------------------------------
  inline ImageVector convertPointerToSubImagePosition(DATATYPE* pointer) const
  { return getStride().getVectorPosition(pointer - static_cast<DATATYPE*>(_data)); }
  
  inline void convertPointerToSubImagePosition(DATATYPE* pointer, MLint* x, MLint* y, MLint* z) const
  {
    ML_TRACE_IN( "TSubImage::convertPointerToSubImagePosition( )" );
    ML_TRY
    {
      const MLint offset = pointer - static_cast<DATATYPE*>(_data);
      const ImageVector stride=getStride();
      const ImageVector imgExt=getImageExtent();
      
      if (x){
        ML_CHECK_THROW(stride.x);
        ML_CHECK_THROW(imgExt.x);
        *x = (offset/stride.x) % imgExt.x;
      }
      
      if (y){
        ML_CHECK_THROW(imgExt.y);
        ML_CHECK_THROW(stride.y);
        *y = (offset/stride.y) % imgExt.y;
      }
      
      if (z){
        ML_CHECK_THROW(imgExt.z);
        ML_CHECK_THROW(stride.z);
        *z = (offset/stride.z) % imgExt.z;
      }
    }
    ML_CATCH_RETHROW;
  }
  

  inline ImageVector convertPointerToImagePosition(DATATYPE* pointer) const
  { return convertPointerToSubImagePosition(pointer) + _box.v1; }


  inline void convertPointerToImagePosition(DATATYPE* pointer, MLint* x, MLint* y, MLint* z) const
  {
    convertPointerToSubImagePosition(pointer, x, y, z);
    if (x){ *x += _box.v1.x; }
    if (y){ *y += _box.v1.y; }
    if (z){ *z += _box.v1.z; }
  }



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

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

  inline const DATATYPE& operator[](const ImageVector& position) const    { return getImagePointer(position)[0]; }

  inline DATATYPE& operator[](const ImageVector& position)    { return getImagePointer(position)[0]; }

  inline void setSubImageValue(const ImageVector& position, DATATYPE value) { static_cast<DATATYPE*>(_data)[ ImageVector::dot(position,_stride) ]=value; }

  inline DATATYPE getSubImageValue(const ImageVector& position) const { return static_cast<DATATYPE*>(_data)[ ImageVector::dot(position,_stride) ]; }

  inline void setSubImageValue(MLint x, MLint y, DATATYPE value)      { static_cast<DATATYPE*>(_data)[ x*_stride.x + y*_stride.y ]=value; }
  inline DATATYPE getSubImageValue(MLint x, MLint y)          const { return static_cast<DATATYPE*>(_data)[ x*_stride.x + y*_stride.y ]; }

  inline void setSubImageValue(MLint x, MLint y, MLint z, DATATYPE value){ static_cast<DATATYPE*>(_data)[ x*_stride.x + y*_stride.y+_stride.z*z ]=value; }
  inline DATATYPE getSubImageValue(MLint x, MLint y, MLint z) const { return static_cast<DATATYPE*>(_data)[ x*_stride.x + y*_stride.y+_stride.z*z ]; }

  inline void setImageValue(const ImageVector& position, DATATYPE value) { getImagePointer(position)[0] = value; }
  inline DATATYPE getImageValue(const ImageVector& position) const { return getImagePointer(position)[0]; }

  inline void setImageValue(MLint x, MLint y, DATATYPE value) { static_cast<DATATYPE*>(_data)[_ML_TSUBIMG_SUBDOT2(x,y,_box.v1, _stride)]=value; }
  inline DATATYPE getImageValue(MLint x, MLint y) const { return static_cast<DATATYPE*>(_data)[_ML_TSUBIMG_SUBDOT2(x,y,_box.v1, _stride)]; }

  inline void setImageValue(MLint x, MLint y, MLint z, DATATYPE value){ getImagePointer(x,y,z)[0] = value; }
  inline DATATYPE getImageValue(MLint x, MLint y, MLint z)    const { return getImagePointer(x,y,z)[0]; }



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

  //---------------------------------------------------------------------------
  MLint calculateMinMax(DATATYPE& minValue, DATATYPE& maxValue, const SubImageBox * const validBox=NULL) const
  {
    ML_TRACE_IN( "TSubImage::calculateMinMax( )" );
    ML_TRY
    {
      // If passed box pointer is valid then compute intersection with
      // this subimage box, otherwise use non intersected subimage box of this.
      const SubImageBox& thisBox = getBox();
      const SubImageBox box     = validBox ? SubImageBox::intersect(thisBox, *validBox) : thisBox;

      // Get number of voxels in subimage. Return 0/0 if subimage is empty.
      const MLint numVoxels = box.getNumVoxels();
      if (numVoxels==0){ minValue=0; maxValue=0; return 0; }

      // Set min/max to first voxel value.
      minValue = maxValue = getImageValue(box.v1);

      // Simply scan all voxels if box is subimage box, it is faster.
      if (box == thisBox){
        // Not empty. Get pointer to voxel directly after last voxel.

        ML_CHECK_THROW(_data);
        const DATATYPE* dataEnd = static_cast<DATATYPE*>(_data) + numVoxels;

        // Scan all voxels starting with the second one.
        for (DATATYPE* i=static_cast<DATATYPE*>(_data)+1; i<dataEnd; ++i)
        {
          if (*i < minValue){ minValue = *i; }
          if (*i > maxValue){ maxValue = *i; }
        }
      }
      else{
        // Loop over all rows of the valid subimage region.
        ImageVector p;
        for (MLint u=box.v1.u; u <= box.v2.u; ++u){
          for (MLint t=box.v1.t; t <= box.v2.t; ++t){
            for (MLint c=box.v1.c; c <= box.v2.c; ++c){
              for (MLint z=box.v1.z; z <= box.v2.z; ++z){
                for (MLint y=box.v1.y; y <= box.v2.y; ++y){
                  // For inner loop move pointer.
                  p.set(box.v1.x, y, z, c, t, u);
                  const DATATYPE *dPtr = getImagePointer(p);
                  const MLint pEnd = box.v2.x;
                  for (MLint x=box.v1.x; x <= pEnd; ++x, ++dPtr){
                    if (*dPtr < minValue){ minValue = *dPtr; }
                    if (*dPtr > maxValue){ maxValue = *dPtr; }
                  }
                }
              }
            }
          }
        }
      }

      // Return how many voxel have been scanned.
      return numVoxels;
    }
    ML_CATCH_RETHROW;
  };

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

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

#define _ML_CHECK_SUBIMAGE_DATA_POINTERS(FROM_PTR, TO_PTR)                            \
  /* Check for valid data pointers to avoid memory access errors. */                  \
  {                                                                                   \
    if (!FROM_PTR || !TO_PTR){                                                        \
      ML_PRINT_ERROR("TSubImage::copySubImageTyped( )",                                   \
                     ML_BAD_POINTER_OR_0,                                             \
                     "Valid data pointers in source and target subimage required for" \
                     "subimage copying, thus call is ignored.");                      \
      return;                                                                         \
    }                                                                                 \
  }

  template <typename FROM_DATATYPE>
  void copySubImageReorderColorPlanesToInterleaved(const TSubImage<FROM_DATATYPE>& typedFromImage, const ScaleShiftData& scaleShiftData)
  {
    ML_TRACE_IN( "TSubImage::copySubImageReorderColorPlanesToInterleaved( )" );
    ML_TRY
    {
      // Copy in local variables to reduce calculations in getBox().
      const SubImageBox& box =getBox();
      const SubImageBox& tBox=typedFromImage.getBox();

      if (box.isEmpty() || tBox.isEmpty()){ return; }

      // Calculate overlap of both subimages and copy only if overlap is not empty.
      const SubImageBox intersection = SubImageBox::intersect(typedFromImage.getBox(),getBox());
      if (!intersection.isEmpty()){

        // Check data pointers and print errors if necessary.
        _ML_CHECK_SUBIMAGE_DATA_POINTERS(typedFromImage.getData(), getData());

        ImageVector p;
        const FROM_DATATYPE* fromPt       = NULL;
        DATATYPE*            toPt         = NULL;

        const ImageVector toExtent = getExtent();
        const ImageVector toStrides = ImageVector(toExtent.c, toExtent.x, toExtent.y, toExtent.z, toExtent.t, toExtent.u).getStrides();
        const ImageVector offsetReordered(_box.v1.c, _box.v1.x, _box.v1.y, _box.v1.z, _box.v1.t, _box.v1.u);

        const MLdouble  scaleDbl  = static_cast<MLdouble>(scaleShiftData.getScale());
        const MLdouble  shiftDbl  = static_cast<MLdouble>(scaleShiftData.getShift());

        // Check for identical scaling.
        const bool identicalScaling = MLValuesAreEqual(scaleDbl, static_cast<MLdouble>(1), static_cast<MLdouble>(1)) &&
                                      MLValuesAreEqual(shiftDbl, static_cast<MLdouble>(0), static_cast<MLdouble>(1));

        // Traverse all voxels.
        if (identicalScaling) {
          for (p.u=intersection.v1.u; p.u<=intersection.v2.u; ++p.u) {
            for (p.t=intersection.v1.t; p.t<=intersection.v2.t; ++p.t) {
              for (p.c=intersection.v1.c; p.c<=intersection.v2.c; ++p.c) {
                for (p.z=intersection.v1.z; p.z<=intersection.v2.z; ++p.z) {
                  for (p.y=intersection.v1.y; p.y<=intersection.v2.y; ++p.y) {

                    const ImageVector pos(intersection.v1.x,p.y,p.z,p.c,p.t,p.u);
                    const ImageVector posReordered(p.c, intersection.v1.x,p.y,p.z,p.t,p.u);
                    fromPt= typedFromImage.getImagePointer(pos);
                    toPt  = static_cast<DATATYPE*>(_data) + _ML_TSUBIMG_SUBDOT6(posReordered, offsetReordered, toStrides);

                    for (p.x = intersection.v1.x; p.x <= intersection.v2.x; ++p.x, ++fromPt) {
                      *toPt = static_cast<DATATYPE>(*fromPt);
                      toPt += toStrides.y;
                    }
                  }
                }
              }
            }
          }
        } else {
          for (p.u=intersection.v1.u; p.u<=intersection.v2.u; ++p.u) {
            for (p.t=intersection.v1.t; p.t<=intersection.v2.t; ++p.t) {
              for (p.c=intersection.v1.c; p.c<=intersection.v2.c; ++p.c) {
                for (p.z=intersection.v1.z; p.z<=intersection.v2.z; ++p.z) {
                  for (p.y=intersection.v1.y; p.y<=intersection.v2.y; ++p.y) {

                    const ImageVector pos(intersection.v1.x,p.y,p.z,p.c,p.t,p.u);
                    const ImageVector posReordered(p.c, intersection.v1.x,p.y,p.z,p.t,p.u);
                    fromPt= typedFromImage.getImagePointer(pos);
                    toPt  = static_cast<DATATYPE*>(_data) + _ML_TSUBIMG_SUBDOT6(posReordered, offsetReordered, toStrides);

                    for (p.x = intersection.v1.x; p.x <= intersection.v2.x; ++p.x, ++fromPt) {
                      *toPt = static_cast<DATATYPE>(static_cast<MLdouble>(*fromPt)*scaleDbl + shiftDbl);
                      toPt += toStrides.y;
                    }
                  }
                }
              }
            }
          }
        }
      } // if (!intersection.isEmpty())
    } // ML_TRY
    ML_CATCH_RETHROW;
  }

  //
  //Note: The following function definition must be implemented in the class definition
  //      See BUG: LNK2001 on Member Function When Use Nested Class Template, Article ID: Q128789
  template <typename FROM_DATATYPE>
  void copySubImageTyped(const TSubImage<FROM_DATATYPE> &typedFromImg, const ScaleShiftData& scaleShiftData)
  {
    ML_TRACE_IN( "TSubImage::copySubImageTyped( )" );
    ML_TRY
    {
      // Any box empty? Then no copy is necessary.
      if (getBox().isEmpty() || typedFromImg.getBox().isEmpty()){
        return;
      }

      if (scaleShiftData.getReorderMode() == ScaleShiftData::ReorderColorPlanesToInterleaved) {
        copySubImageReorderColorPlanesToInterleaved(typedFromImg, scaleShiftData);
        return;
      }

      // Get double and long double versions of scale and shift values.
      const MLdouble  scaleDbl  = scaleShiftData.getScale();
      const MLdouble  shiftDbl  = scaleShiftData.getShift();

      // Check for identical scaling and use default copying then.
      if (MLValuesAreEqual(scaleDbl, 1.0, 1.0) && MLValuesAreEqual(shiftDbl, 0.0, 1.0)){
        copySubImage(typedFromImg);
        return;
      }

      // Get data type properties. If we calculate with normal data types then we calculate in double values;
      // on long double built-in types we use long double, and if we use extended types we remain in extended types.
      const MLint isDTScalarType  = MLIsScalarTypePtr(static_cast<DATATYPE*>(NULL));
      const MLint isFDTScalarType = MLIsScalarTypePtr(static_cast<FROM_DATATYPE*>(NULL));

      if (getDataType()==typedFromImg.getDataType()){
        if (getBox()==typedFromImg.getBox()){
          // Images have same data type and same position/extent:
          //-----------------------------------------------------
          const FROM_DATATYPE  *fromPt  = typedFromImg.getData();
          DATATYPE       *toPt    = getData();

          // Check data pointers and print errors if necessary.
          _ML_CHECK_SUBIMAGE_DATA_POINTERS(fromPt, toPt);

          // Get number and the size in bytes of all voxels of this subimage.
          const MLint size     = getNumVoxels();
          const MLint bytesize = size * MLSizeOf(getDataType());

          // Copy the memory to the target buffer, it must fit since types are identical.
          memcpy( toPt, fromPt, bytesize );

          // When we work with extended types we must avoid to change to double during calculations since
          // that causes information loss. In normal case we remain in double.
          if (!isDTScalarType){
            // NOTE/TODO:
            // Currently extended types must support adding and multiplying with doubles
            // for this to work.
            for (DATATYPE* toPtEnd=toPt+size; toPt<toPtEnd; ++toPt){
              *toPt=static_cast<DATATYPE>(static_cast<DATATYPE>(*toPt)*scaleDbl + shiftDbl);
            }
          }
          else{
            for (DATATYPE* toPtEnd=toPt+size; toPt<toPtEnd; ++toPt){
              *toPt=static_cast<DATATYPE>( static_cast<MLdouble>(*toPt)*scaleDbl + shiftDbl);
            }
          }
        }
        else{
          // Images have same data type:
          //----------------------------
          // Calculate intersection of both subimages. Copy only if intersection is not empty.
          const SubImageBox intersection = SubImageBox::intersect(typedFromImg.getBox(),getBox());
          if (!intersection.isEmpty()){

            // Check data pointers and print errors if necessary.
            _ML_CHECK_SUBIMAGE_DATA_POINTERS(typedFromImg.getData(), getData());

            ImageVector p;
            const FROM_DATATYPE *fromPt  = NULL;
            DATATYPE       *toPt         = NULL,
                           *toPt_        = NULL,
                           *toPtEnd      = NULL;
            const ImageVector    fromStr      = typedFromImg.getStride();
            const ImageVector    toStr        = getStride();
            const MLint dist       = intersection.v2.x - intersection.v1.x;
            const MLint size_x     = dist+1;
            const MLint bytesize_x = size_x * MLSizeOf(getDataType());

            // Traverse all 6 dimensions.
            for (p.u=intersection.v1.u; p.u<=intersection.v2.u; ++p.u){
              for (p.t=intersection.v1.t; p.t<=intersection.v2.t; ++p.t){
                for (p.c=intersection.v1.c; p.c<=intersection.v2.c; ++p.c){
                  for (p.z=intersection.v1.z; p.z<=intersection.v2.z; ++p.z){

                    // Get start position to each slice of data.
                    const ImageVector pos(intersection.v1.x, intersection.v1.y, p.z, p.c, p.t, p.u);
                    fromPt = typedFromImg.getImagePointer(pos);
                    toPt   =              getImagePointer(pos);
                    ML_CHECK_THROW(fromPt);
                    ML_CHECK_THROW(toPt);

                    for (p.y=intersection.v1.y; p.y<=intersection.v2.y; ++p.y,fromPt+=fromStr.y,toPt+=toStr.y){

                      // Copy buffer to target buffer. Below we work only on one buffer for rescaling.
                      memcpy(toPt, fromPt, bytesize_x);
                      toPt_ = toPt;

                      if (!isDTScalarType){
                        // See description in upper case "if (getDataType()==typedFromImg.getDataType())".
                        for (toPtEnd = toPt_+size_x;
                             toPt_<toPtEnd;
                             ++toPt_){
                          *toPt_=static_cast<DATATYPE>(static_cast<DATATYPE>(*toPt_)*scaleDbl + shiftDbl);
                        }
                      }
                      else{
                        for (toPtEnd = toPt_+size_x;
                             toPt_<toPtEnd;
                             ++toPt_){
                          *toPt_=static_cast<DATATYPE>(static_cast<MLdouble>(*toPt_)*scaleDbl + shiftDbl);
                        }
                      }
                    }
                  }
                }
              }
            }
          } // if (!intersection.isEmpty())
        } // else
      } // if (getDataType()==typedFromImg.getDataType())

      // Images have different data type:
      //---------------------------------
      else{
        // Copy overlap of both subimages and copy only if it is not empty.
        const SubImageBox intersection = SubImageBox::intersect(typedFromImg.getBox(),getBox());
        if (!intersection.isEmpty()){

          // Check data pointers and print errors if necessary.
          _ML_CHECK_SUBIMAGE_DATA_POINTERS(typedFromImg.getData(), getData());

          ImageVector p;
          const FROM_DATATYPE  *fromPt = NULL;
          DATATYPE       *toPt         = NULL;

          // Traverse all 6 dimensions.
          for (p.u=intersection.v1.u; p.u<=intersection.v2.u; ++p.u){
            for (p.t=intersection.v1.t; p.t<=intersection.v2.t; ++p.t){
              for (p.c=intersection.v1.c; p.c<=intersection.v2.c; ++p.c){
                for (p.z=intersection.v1.z; p.z<=intersection.v2.z; ++p.z){
                  for (p.y=intersection.v1.y; p.y<=intersection.v2.y; ++p.y){

                    // Get start position to each slice of data.
                    const ImageVector pos(intersection.v1.x,p.y,p.z,p.c,p.t,p.u);
                    fromPt = typedFromImg.getImagePointer(pos);
                    toPt   =              getImagePointer(pos);
                    const MLint startX = intersection.v1.x;
                    const MLint endX   = intersection.v2.x;

                    if (!isFDTScalarType){
                      // When we work with extended types we must avoid to change to double during calculations since
                      // that causes information loss. In normal case we remain in double.
                      for (p.x = startX;  p.x <= endX;  ++p.x, ++fromPt, ++toPt){
                        *toPt=static_cast<DATATYPE>(static_cast<FROM_DATATYPE>(*fromPt)*scaleDbl + shiftDbl);
                      }
                    }
                    else{
                      for (p.x = startX;  p.x <= endX;  ++p.x, ++fromPt, ++toPt){
                        *toPt=static_cast<DATATYPE>(static_cast<MLdouble>(*fromPt)*scaleDbl + shiftDbl);
                      }
                    }
                  }
                }
              }
            }
          } // for (p.u)

        } // if (!intersection.isEmpty())

      } // else of if (getDataType()==typedFromImg.getDataType())
    }
    ML_CATCH_RETHROW;
  }




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

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

  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  inline void fill(DATATYPE value)
  {
    ML_TRACE_IN( "TSubImage::fill( )" );
    ML_TRY
    {
      ML_CHECK_THROW(_data);

      const DATATYPE* dataEnd = static_cast<DATATYPE*>(_data) + getNumVoxels();

      for (DATATYPE* i = static_cast<DATATYPE*>(_data); i<dataEnd; ++i){ *i=value; }
    }
    ML_CATCH_RETHROW;
  };


  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  inline void fillBordersWithValue(const SubImageBox& box, DATATYPE fillValue)
  {
    SubImage::fillBordersWithTypeData(box, reinterpret_cast<const MLTypeData*>(&fillValue));
  }

  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  inline void fillInvalidRegionWithValue(DATATYPE value) {
    fillBordersWithValue(getValidRegion(), value);
  }

  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  inline void fillInvalidRegionWithBorderValues() {
    fillBordersWithBorderValues(getValidRegion());
  }


#ifdef ML_DEPRECATED
  

  
public:
  
  inline ML_DEPRECATED const DATATYPE* getSubImgPos(const ImageVector &p) const { return getSubImagePointer(p); }
  inline ML_DEPRECATED       DATATYPE* getSubImgPos(const ImageVector &p) { return getSubImagePointer(p); }
  inline ML_DEPRECATED const DATATYPE* getSubImgPos(MLint x, MLint y, MLint z) const { return getSubImagePointer(x, y, z); }
  inline ML_DEPRECATED       DATATYPE* getSubImgPos(MLint x, MLint y, MLint z) { return getSubImagePointer(x, y, z); }
  inline ML_DEPRECATED const DATATYPE* getImgPos(const ImageVector &p) const { return getImagePointer(p); }
  inline ML_DEPRECATED       DATATYPE* getImgPos(const ImageVector &p) { return getImagePointer(p); }
  inline ML_DEPRECATED const DATATYPE* getImgPos(MLint x, MLint y, MLint z) const { return getImagePointer(x, y, z); }
  inline ML_DEPRECATED       DATATYPE* getImgPos(MLint x, MLint y, MLint z) { return getImagePointer(x, y, z); }
  inline ML_DEPRECATED ImageVector getSubImgCoords(DATATYPE *pos) const { return convertPointerToSubImagePosition(pos); }
  inline ML_DEPRECATED void getSubImgCoords(DATATYPE *pos, MLint *x, MLint *y, MLint *z) const { convertPointerToSubImagePosition(pos, x, y, z); }
  inline ML_DEPRECATED ImageVector getImgCoords(DATATYPE *pos) const { return convertPointerToImagePosition(pos); }
  inline ML_DEPRECATED void getImgCoords(DATATYPE *pos, MLint *x, MLint *y, MLint *z) const { convertPointerToImagePosition(pos, x, y, z); }
  inline ML_DEPRECATED void setSubImgVal(const ImageVector& p, DATATYPE val) { setSubImageValue(p, val); }
  inline ML_DEPRECATED DATATYPE getSubImgVal(const ImageVector& p) const { return getSubImageValue(p); }
  inline ML_DEPRECATED void setSubImgVal(MLint x, MLint y, DATATYPE val) { setSubImageValue(x, y, val); }
  inline ML_DEPRECATED DATATYPE getSubImgVal(MLint x, MLint y) const { return getSubImageValue(x, y); }
  inline ML_DEPRECATED void setSubImgVal(MLint x, MLint y, MLint z, DATATYPE val){ setSubImageValue(x, y, z, val); }
  inline ML_DEPRECATED DATATYPE getSubImgVal(MLint x, MLint y, MLint z) const { return getSubImageValue(x, y, z); }
  inline ML_DEPRECATED void setImgVal(const ImageVector& p, DATATYPE val) { setImageValue(p, val); }
  inline ML_DEPRECATED DATATYPE getImgVal(const ImageVector& p) const { return getImageValue(p); }
  inline ML_DEPRECATED void setImgVal(MLint x, MLint y, DATATYPE val) { setImageValue(x, y, val); }
  inline ML_DEPRECATED DATATYPE getImgVal(MLint x, MLint y) const { return getImageValue(x, y); }
  inline ML_DEPRECATED void setImgVal(MLint x, MLint y, MLint z, DATATYPE val){ setImageValue(x, y, z, val); }
  inline ML_DEPRECATED DATATYPE getImgVal(MLint x, MLint y, MLint z) const { return getImageValue(x, y, z); }
  inline ML_DEPRECATED MLint calcMinMax(DATATYPE &minVal, DATATYPE &maxVal, const SubImageBox * const validBox=NULL) const { return calculateMinMax(minVal, maxVal, validBox); }
  template <typename FROM_DATATYPE>
  ML_DEPRECATED void copySubImg(const TSubImage<FROM_DATATYPE> &typedFromImg) { copySubImage(typedFromImg); }
  template <typename FROM_DATATYPE>
  ML_DEPRECATED void copySubImg(const TSubImage<FROM_DATATYPE> &typedFromImg, const ScaleShiftData& scaleShiftData) { copySubImage(typedFromImg, scaleShiftData); }
  inline ML_DEPRECATED void fillSubImg(DATATYPE value) { fill(value);}
  
  inline ML_DEPRECATED void fillBordersWithClampedInputValues(const SubImageBox& box) { fillBordersWithBorderValues(box); }

  inline ML_DEPRECATED void fillBordersWithFillValue(const SubImageBox& box, DATATYPE value) { fillBordersWithValue(box, value); }

  
#endif // ML_DEPRECATED

};

#ifdef ML_DEPRECATED




#define TSubImg TSubImage

#if defined(WIN32) && defined(ML_WARN_DEPRECATED)
#pragma deprecated("TSubImg")
#endif

#endif // ML_DEPRECATED


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <typename DATATYPE>
class TSubImageCursorBase {

protected:

  TSubImageCursorBase(const TSubImage<DATATYPE>& subImage) {
    _data = const_cast<DATATYPE*>(subImage.getData());
    _subImageOffset = subImage.getBox().v1;
    _stride = subImage.getStride();
    _cursor = _data;
  }

public:

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

  //---------------------------------------------------------------------------
  inline void      setSubImagePosition(const ImageVector& position) { _cursor = _data+ImageVector::dot(position,_stride); }
  inline void      setSubImagePosition(MLint x, MLint y, MLint z) { _cursor = _data+_stride.x*x+_stride.y*y+_stride.z*z; }
  inline void      setImagePosition(const ImageVector& position) { _cursor = _data + _ML_TSUBIMG_SUBDOT6(position,_subImageOffset,_stride); }
  inline void      setImagePosition(MLint x, MLint y, MLint z)    { _cursor = _data+ + _ML_TSUBIMG_SUBDOT3(x,y,z,_subImageOffset,_stride); }
  inline void      setPosition(const DATATYPE *pointer) { _cursor = const_cast<DATATYPE*>(pointer); }
  inline void      moveByOffset(const ImageVector& offset) { _cursor += ImageVector::dot(offset,_stride); }
  inline void      moveByOffset(MLint x, MLint y, MLint z) { _cursor += _stride.x*x+_stride.y*y+_stride.z*z; }
  inline void      moveX() { _cursor += _stride.x; }
  inline void      moveY() { _cursor += _stride.y; }
  inline void      moveZ() { _cursor += _stride.z; }
  inline void      moveC() { _cursor += _stride.c; }
  inline void      moveT() { _cursor += _stride.t; }
  inline void      moveU() { _cursor += _stride.u; }
  inline void      reverseMoveX() { _cursor -= _stride.x; }
  inline void      reverseMoveY() { _cursor -= _stride.y; }
  inline void      reverseMoveZ() { _cursor -= _stride.z; }
  inline void      reverseMoveC() { _cursor -= _stride.c; }
  inline void      reverseMoveT() { _cursor -= _stride.t; }
  inline void      reverseMoveU() { _cursor -= _stride.u; }


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

  // Note: All these functions do not need explicit 64 bit arithmetic, because
  //       pointer arithmetic always goes from valid address area to another
  //       valid address area even on 32 systems and calculations do not fall
  //       outside valid ranges.
  //---------------------------------------------------------------------------
  inline DATATYPE getValue() const { return *(_cursor); }

  inline DATATYPE getValueWithOffset(const ImageVector& offset) const { return *(_cursor+ImageVector::dot(offset,_stride)); }

  inline DATATYPE getValueWithOffset(MLint dx, MLint dy, MLint dz) const { return *(_cursor+_stride.x*dx+_stride.y*dy+_stride.z*dz); }


protected:
  DATATYPE* _data;
  ImageVector _subImageOffset;
  ImageVector _stride;
  DATATYPE* _cursor;


#ifdef ML_DEPRECATED 
  


public:
  
  inline ML_DEPRECATED void setCursorSubImgPos(const ImageVector& p) { setSubImagePosition(p); }  
  inline ML_DEPRECATED void setCursorSubImgPos(MLint x, MLint y, MLint z) { setSubImagePosition(x, y, z); }  
  inline ML_DEPRECATED void setCursorImgPos(const ImageVector& p) { setImagePosition(p); }
  inline ML_DEPRECATED void setCursorImgPos(MLint x, MLint y, MLint z) { setImagePosition(x, y, z); }
  inline ML_DEPRECATED void setCursorPos(const DATATYPE *position) { setPosition(position); }
  inline ML_DEPRECATED void moveCursor(const ImageVector& dp) { moveByOffset(dp); }  
  inline ML_DEPRECATED void moveCursor(MLint x, MLint y, MLint z) { moveByOffset(x, y, z); }
  inline ML_DEPRECATED void moveCursorX() { moveX(); }
  inline ML_DEPRECATED void moveCursorY() { moveY(); }
  inline ML_DEPRECATED void moveCursorZ() { moveZ(); }
  inline ML_DEPRECATED void moveCursorC() { moveC(); }
  inline ML_DEPRECATED void moveCursorT() { moveT(); }
  inline ML_DEPRECATED void moveCursorU() { moveU(); }
  inline ML_DEPRECATED void moveCursorBX() { reverseMoveX(); }
  inline ML_DEPRECATED void moveCursorBY() { reverseMoveY(); }
  inline ML_DEPRECATED void moveCursorBZ() { reverseMoveZ(); }
  inline ML_DEPRECATED void moveCursorBC() { reverseMoveC(); }
  inline ML_DEPRECATED void moveCursorBT() { reverseMoveT(); }
  inline ML_DEPRECATED void moveCursorBU() { reverseMoveU(); }
  inline DATATYPE getCursorVal() const { return getValue(); }
  inline DATATYPE getCursorVal(const ImageVector& dp) const { return getValueWithOffset(dp); }
  inline DATATYPE getCursorVal(MLint dx, MLint dy, MLint dz) const { return getValueWithOffset(dx, dy, dz); }
    
  
#endif // ML_DEPRECATED
  
};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <typename DATATYPE>
class ConstTSubImageCursor : public TSubImageCursorBase<DATATYPE> {

typedef TSubImageCursorBase<DATATYPE> T;

public:
  ConstTSubImageCursor(const TSubImage<DATATYPE>& subImage) : TSubImageCursorBase<DATATYPE>(subImage) {
  }

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



  inline const DATATYPE* getPointer() const { return T::_cursor; }
  inline const DATATYPE* getPointerWithOffset(const ImageVector& offset) const { return T::_cursor+ImageVector::dot(offset,T::_stride); }
  inline const DATATYPE* getPointerWithOffset(MLint dx, MLint dy, MLint dz) const { return (T::_cursor+T::_stride.x*dx+T::_stride.y*dy+T::_stride.z*dz); }

  
#ifdef ML_DEPRECATED
  

  
public:

  inline ML_DEPRECATED const DATATYPE* getCursorPos() const { return getPointer(); }  
  inline ML_DEPRECATED const DATATYPE* getCursorPos(const ImageVector& dp) const { return getPointerWithOffset(dp); }  
  inline ML_DEPRECATED const DATATYPE* getCursorPos(MLint dx, MLint dy, MLint dz) const { return getPointerWithOffset(dx, dy, dz); }
  
  
#endif // ML_DEPRECATED
    
};

#ifdef ML_DEPRECATED




#define ConstTSubImgCursor ConstTSubImageCursor

#if defined(WIN32) && defined(ML_WARN_DEPRECATED)
#pragma deprecated("ConstTSubImgCursor")
#endif

#endif // ML_DEPRECATED


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <typename DATATYPE>
class TSubImageCursor : public TSubImageCursorBase<DATATYPE> {

typedef TSubImageCursorBase<DATATYPE> T;

public:
  
  TSubImageCursor(TSubImage<DATATYPE>& subImage) : TSubImageCursorBase<DATATYPE>(subImage) {
  }

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



  inline DATATYPE* getPointer() const { return T::_cursor; }
  inline DATATYPE* getPointerWithOffset(const ImageVector& offset) const { return T::_cursor+ImageVector::dot(offset,T::_stride); }
  inline DATATYPE* getPointerWithOffset(MLint dx, MLint dy, MLint dz) const { return (T::_cursor+T::_stride.x*dx+T::_stride.y*dy+T::_stride.z*dz); }

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

  // Note: All these functions do not need explicit 64 bit arithmetic, because
  //       pointer arithmetic always goes from valid address area to another
  //       valid address area even on 32 systems and calculations do not fall
  //       outside valid ranges.
  //---------------------------------------------------------------------------
  inline void setValue(DATATYPE value) const { *(T::_cursor) = value; }
  inline void setValueWithOffset(const ImageVector& offset, DATATYPE value) const { *(T::_cursor+ImageVector::dot(offset,T::_stride))=value; }
  inline void setValueWithOffset(MLint dx, MLint dy, MLint dz, DATATYPE value) const { *(T::_cursor+T::_stride.x*dx+T::_stride.y*dy+T::_stride.z*dz)=value; }
  
#ifdef ML_DEPRECATED 
  

  
public:
  
  inline ML_DEPRECATED DATATYPE* getCursorPos() const { return getPointer(); }
  inline ML_DEPRECATED DATATYPE* getCursorPos(const ImageVector& dp) const { return getPointerWithOffset(dp); }  
  inline ML_DEPRECATED DATATYPE* getCursorPos(MLint dx, MLint dy, MLint dz) const { return getPointerWithOffset(dx, dy, dz); }
  inline ML_DEPRECATED void setCursorVal(DATATYPE val) const { setValue(val); }
  inline ML_DEPRECATED void setCursorVal(const ImageVector& dp, DATATYPE val) const { setValueWithOffset(dp, val); }
  inline ML_DEPRECATED void setCursorVal(MLint dx, MLint dy, MLint dz, DATATYPE val) const { setValueWithOffset(dx, dy, dz, val); }
  
  
#endif // ML_DEPRECATED
  
};

#ifdef ML_DEPRECATED




#define TSubImgCursor TSubImageCursor

#if defined(WIN32) && defined(ML_WARN_DEPRECATED)
#pragma deprecated("TSubImgCursor")
#endif

#endif // ML_DEPRECATED


//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
template <typename DATATYPE>
class TSubImageWithCursor : public TSubImage<DATATYPE>
{
  typedef TSubImage<DATATYPE> T;

public:
  TSubImageWithCursor():TSubImage<DATATYPE>(), _cursor(NULL)
  {
  }
  TSubImageWithCursor(const TSubImage<DATATYPE>& subImage):TSubImage<DATATYPE>(subImage), _cursor(NULL)
  {
  }

  TSubImageWithCursor(const SubImage& subImage):TSubImage<DATATYPE>(subImage), _cursor(NULL)
  {
  }

  TSubImageWithCursor(const TSubImageWithCursor& subImage):TSubImage<DATATYPE>(subImage),_cursor(subImage._cursor)
  {
  }

  inline TSubImageWithCursor &operator=(const TSubImageWithCursor<DATATYPE> &tSubImg)
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageWithCursor::operator=( )" );
    ML_TRY
    {
      TSubImage<DATATYPE>::operator=(tSubImg);
      _cursor = tSubImg._cursor;
      return *this;
    }
    ML_CATCH_RETHROW;
  }

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

  //---------------------------------------------------------------------------
  inline void setCursorSubImagePosition(const ImageVector& position) { _cursor = static_cast<DATATYPE*>(T::_data)+ImageVector::dot(position,T::_stride); }
  inline void setCursorSubImagePosition(MLint x, MLint y, MLint z) { _cursor = static_cast<DATATYPE*>(T::_data)+T::_stride.x*x+T::_stride.y*y+T::_stride.z*z; }
  inline void setCursorImagePosition(const ImageVector& position) { _cursor = static_cast<DATATYPE*>(T::_data)+ _ML_TSUBIMG_SUBDOT6(position, T::_box.v1 ,T::_stride); }
  inline void setCursorImagePosition(MLint x, MLint y, MLint z) { _cursor = static_cast<DATATYPE*>(T::_data)+ _ML_TSUBIMG_SUBDOT3(x,y,z, T::_box.v1 ,T::_stride); }
  inline void setCursorPosition(const DATATYPE* pointer) { _cursor = const_cast<DATATYPE*>(pointer); }
  inline void moveCursorByOffset(const ImageVector& offset) { _cursor += ImageVector::dot(offset,T::_stride); }
  inline void moveCursorByOffset(MLint x, MLint y, MLint z) { _cursor += T::_stride.x*x+T::_stride.y*y+T::_stride.z*z; }
  inline void moveCursorX() { _cursor += T::_stride.x; }
  inline void moveCursorY() { _cursor += T::_stride.y; }
  inline void moveCursorZ() { _cursor += T::_stride.z; }
  inline void moveCursorC() { _cursor += T::_stride.c; }
  inline void moveCursorT() { _cursor += T::_stride.t; }
  inline void moveCursorU() { _cursor += T::_stride.u; }
  inline void reverseMoveCursorX() { _cursor -= T::_stride.x; }
  inline void reverseMoveCursorY() { _cursor -= T::_stride.y; }
  inline void reverseMoveCursorZ() { _cursor -= T::_stride.z; }
  inline void reverseMoveCursorC() { _cursor -= T::_stride.c; }
  inline void reverseMoveCursorT() { _cursor -= T::_stride.t; }
  inline void reverseMoveCursorU() { _cursor -= T::_stride.u; }


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

  // Note: All these functions do not need explicit 64 bit arithmetic, because
  //       pointer arithmetic always goes from valid address area to another
  //       valid address area even on 32 systems and calculations do not fall
  //       outside valid ranges.
  //---------------------------------------------------------------------------
  inline DATATYPE getCursorValue() const { return *(_cursor); }
  inline DATATYPE getCursorValueWithOffset(const ImageVector& offset) const { return *(_cursor+ImageVector::dot(offset,T::_stride)); }
  inline DATATYPE getCursorValueWithOffset(MLint dx, MLint dy, MLint dz) const { return *(_cursor+T::_stride.x*dx+T::_stride.y*dy+T::_stride.z*dz); }


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



  inline DATATYPE* getCursorPointer() const { return _cursor; }
  inline DATATYPE* getCursorPointerWithOffset(const ImageVector& offset) const { return _cursor+ImageVector::dot(offset,T::_stride); }
  inline DATATYPE* getCursorPointerWithOffset(MLint dx, MLint dy, MLint dz) const { return (_cursor+T::_stride.x*dx+T::_stride.y*dy+T::_stride.z*dz); }

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

  // Note: All these functions do not need explicit 64 bit arithmetic, because
  //       pointer arithmetic always goes from valid address area to another
  //       valid address area even on 32 systems and calculations do not fall
  //       outside valid ranges.
  //---------------------------------------------------------------------------
  inline void setCursorValue(DATATYPE value) { *(_cursor) = value; }
  inline void setCursorValueWithOffset(const ImageVector& offset, DATATYPE value) { *(_cursor+ImageVector::dot(offset,T::_stride))=value; }
  inline void setCursorValueWithOffset(MLint dx, MLint dy, MLint dz, DATATYPE value) { *(_cursor+T::_stride.x*dx+T::_stride.y*dy+T::_stride.z*dz)=value; }


private:
  DATATYPE* _cursor;
  
  
#ifdef ML_DEPRECATED 
  

  
public:

  inline ML_DEPRECATED void setCursorSubImgPos(const ImageVector& p) { setCursorSubImagePosition(p); }
  inline ML_DEPRECATED void setCursorSubImgPos(MLint x, MLint y, MLint z) { setCursorSubImagePosition(x, y, z); }
  inline ML_DEPRECATED void setCursorImgPos(const ImageVector& p) { setCursorImagePosition(p); }
  inline ML_DEPRECATED void setCursorImgPos(MLint x, MLint y, MLint z) { setCursorImagePosition(x, y, z); }
  inline ML_DEPRECATED void setCursorPos(const DATATYPE* position) { setCursorPosition(position); }
  inline ML_DEPRECATED void moveCursor(const ImageVector& dp) { moveCursorByOffset(dp); }
  inline ML_DEPRECATED void moveCursor(MLint x, MLint y, MLint z) { moveCursorByOffset(x, y, z); }
  inline ML_DEPRECATED void moveCursorBX() { reverseMoveCursorX(); }
  inline ML_DEPRECATED void moveCursorBY() { reverseMoveCursorY(); }
  inline ML_DEPRECATED void moveCursorBZ() { reverseMoveCursorZ(); }
  inline ML_DEPRECATED void moveCursorBC() { reverseMoveCursorC(); }
  inline ML_DEPRECATED void moveCursorBT() { reverseMoveCursorT(); }
  inline ML_DEPRECATED void moveCursorBU() { reverseMoveCursorU(); }
  inline ML_DEPRECATED DATATYPE getCursorVal() const { return getCursorValue(); }
  inline ML_DEPRECATED DATATYPE getCursorVal(const ImageVector& dp) const { return getCursorValueWithOffset(dp); }
  inline ML_DEPRECATED DATATYPE getCursorVal(MLint dx, MLint dy, MLint dz) const { return getCursorValueWithOffset(dx, dy, dz); }
  inline ML_DEPRECATED DATATYPE* getCursorPos() const { return getCursorPointer(); }
  inline ML_DEPRECATED DATATYPE* getCursorPos(const ImageVector& dp) const { return getCursorPointerWithOffset(dp); }
  inline ML_DEPRECATED DATATYPE* getCursorPos(MLint dx, MLint dy, MLint dz) const { return getCursorPointerWithOffset(dx, dy, dz); }
  inline void setCursorVal(DATATYPE val) { setCursorValue(val); }
  inline void setCursorVal(const ImageVector& dp, DATATYPE val) { setCursorValueWithOffset(dp, val); }
  inline void setCursorVal(MLint dx, MLint dy, MLint dz, DATATYPE val) { setCursorValueWithOffset(dx, dy, dz, val); }
  
  
#endif // ML_DEPRECATED
    
};

#ifdef ML_DEPRECATED




#define TSubImgWithCursor TSubImageWithCursor 

#if defined(WIN32) && defined(ML_WARN_DEPRECATED)
#pragma deprecated("TSubImgWithCursor")
#endif

#endif // ML_DEPRECATED

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









//---------------------------------------------------------------------------
template <typename T>
TSubImage<T>& tsubimage_cast(SubImage& subImg)
{
  // Check whether template type and real data type match if there is valid data.
  if (subImg.getData() && !TypeTraits<T>::matches(subImg.getDataType()) )
  {
    ML_PRINT_FATAL_ERROR("tsubimage_cast", ML_BAD_DATA_TYPE,
      "Mismatch of data type between argument and template typename.");
  }
  return *(static_cast<TSubImage<T>* >(&subImg));
}

template <typename T>
const TSubImage<T>& tsubimage_cast(const SubImage& subImg)
{
  // Check whether template type and real data type match if there is valid data.
  if (subImg.getData() && !TypeTraits<T>::matches(subImg.getDataType()) )
  {
    ML_PRINT_FATAL_ERROR("tsubimage_cast", ML_BAD_DATA_TYPE,
      "Mismatch of data type between argument and template typename.");
  }
  return *(static_cast<const TSubImage<T>* >(&subImg));
}

template <typename T>
TSubImage<T>* tsubimage_cast(SubImage* subImg)
{
  // Check whether template type and real data type match if there is valid data.
  if (subImg->getData() && !TypeTraits<T>::matches(subImg->getDataType()) )
  {
    ML_PRINT_FATAL_ERROR("tsubimage_cast", ML_BAD_DATA_TYPE,
      "Mismatch of data type between argument and template typename.");
  }
  return static_cast<TSubImage<T>* >(subImg);
}

template <typename T>
const TSubImage<T>* tsubimage_cast(const SubImage* subImg)
{
  // Check whether template type and real data type match if there is valid data.
  if (subImg->getData() && !TypeTraits<T>::matches(subImg->getDataType()) )
  {
    ML_PRINT_FATAL_ERROR("tsubimage_cast", ML_BAD_DATA_TYPE,
      "Mismatch of data type between argument and template typename.");
  }
  return static_cast<const TSubImage<T>* >(subImg);
}


#ifdef ML_DEPRECATED

template <typename T>
TSubImage<T>* tsubimg_cast(SubImage* subImg) { return tsubimage_cast<T>(subImg); }

template <typename T>
const TSubImage<T>* tsubimg_cast(const SubImage* subImg) { return tsubimage_cast<T>(subImg); }

template <typename T>
TSubImage<T>& tsubimg_cast(SubImage& subImg) { return tsubimage_cast<T>(subImg); }

template <typename T>
const TSubImage<T>& tsubimg_cast(const SubImage& subImg) { return tsubimage_cast<T>(subImg); }


#endif


ML_END_NAMESPACE

namespace std {

  //---------------------------------------------------------------------------
  //         Debug printing for TSubImage.
  //---------------------------------------------------------------------------

  template <typename DATATYPE>
  inline ostream &operator<<(ostream &ostr, const ML_NAMESPACE::TSubImage<DATATYPE> &v)
  {
    // Get box of subimage and traverse all of its voxels.
    const ML_NAMESPACE::SubImageBox& box = v.getBox();
    ML_NAMESPACE::ImageVector p;
    for (p.u=box.v1.u; p.u<=box.v2.u; ++p.u){
      for (p.t=box.v1.t; p.t<=box.v2.t; ++p.t){
        for (p.c=box.v1.c; p.c<=box.v2.c; ++p.c){
          for (p.z=box.v1.z; p.z<=box.v2.z; ++p.z){
            for (p.y=box.v1.y; p.y<=box.v2.y; ++p.y){
              // Print row of voxels after a single row start position.
              p.x = box.v1.x;
              ostr << p << ": ";
              for (; p.x<=box.v2.x; p.x++){
                ostr << v.getImageValue(p) << " ";
              }
              ostr << std::endl;
            }
          }
        }
      }
    }
    return ostr;
  }

}

#ifdef _MSC_VER
#pragma warning(pop)
#endif


#endif //of __mlTSubImage_H