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

Go to the documentation of this file.

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

//ML-includes
#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif
#ifndef __mlImageVector_H
#include "mlImageVector.h"
#endif

ML_START_NAMESPACE

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
template<typename intT> class TSubImageBox
{
  
public:
  typedef TImageVector<intT> VectorType;

  VectorType v1;
  
  VectorType v2;
  
  //------------------------------------------------------

  //------------------------------------------------------
  inline TSubImageBox() : v1(0), v2(-1)
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox( )" );
  }
  
  inline TSubImageBox(const VectorType& vector1, const VectorType& vector2) : v1(vector1), v2(vector2)
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox( )" );
  }
  
  inline TSubImageBox(const VectorType extent) : v1(0), v2(extent-1)                         
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox( )" );
  }
  
  
  
  //------------------------------------------------------

  //------------------------------------------------------
  bool operator==(const TSubImageBox<intT>& box) const 
  { 
    return (v1==box.v1) && (v2==box.v2); 
  }
  
  bool operator!=(const TSubImageBox<intT>& box) const 
  { 
    return (v1!=box.v1) || (v2!=box.v2); 
  }
  
  bool isEmpty() const
  { 
    return (v1.x>v2.x) || (v1.y>v2.y) || (v1.z>v2.z) || (v1.c>v2.c) ||  (v1.t>v2.t) || (v1.u>v2.u);  
  }
  
  intT getNumVoxels() const
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox::getNumVoxels( )" );
    
    if (isEmpty())
    { 
      return 0; 
    } 
    else 
    { 
      return VectorType::compMul((v2-v1)+VectorType(1)); 
    }
  }
  
  VectorType getExtent() const 
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox::getExtent( )" );
    
    if (isEmpty())
    { 
      return VectorType(0); 
    } 
    else 
    { 
      return (v2-v1)+VectorType(1); 
    }
  }
  
  
  void correct();
  
  
  
  //------------------------------------------------------

  //------------------------------------------------------
  static TSubImageBox<intT> intersect(const TSubImageBox<intT>& box1, const TSubImageBox<intT>& box2);
  
  static TSubImageBox<intT> merge(const TSubImageBox<intT>& box1, const TSubImageBox<intT>& box2);
  
  void makeEmpty()                                         
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox::makeEmpty( )" );
    
    v1.set(0); 
    v2.set(-1); 
  }
  
  TSubImageBox<intT> intersect(const TSubImageBox<intT>& box) const
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox::intersect( )" );
    
    return TSubImageBox<intT>::intersect(*this, box); 
  }
  
  TSubImageBox<intT> merge(const TSubImageBox<intT>& box) const
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox::merge( )" );
    
    return TSubImageBox<intT>::merge(*this, box); 
  }
  
  VectorType clamp(const VectorType& position) const;
  
  inline bool contains (const VectorType& position) const    
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox::contains ( )" );
    
    return (position >= v1) && (position <= v2); 
  }
  
  inline void translate(const VectorType& offsetVector)          
  {
    ML_TRACE_IN_TIME_CRITICAL( "TSubImageBox::translate( )" );
    
    v1 = v1+offsetVector; 
    v2 = v2+offsetVector;              
  }
  
  static void get3DCorners(const TSubImageBox<intT>& box, VectorType corners[8])
  {
    ML_TRACE_IN( "TSubImageBox::get3DCorners( )" );
    ML_TRY
    {
      if (box.isEmpty()){ 
        for (int c=0; c < 8; c++){ corners[c] = ImageVector(0); }
      }
      else{
        corners[0] = box.v1;
        corners[1] = ImageVector(box.v1.x, box.v1.y, box.v2.z,0,0,0);
        corners[2] = ImageVector(box.v1.x, box.v2.y, box.v1.z,0,0,0);
        corners[3] = ImageVector(box.v1.x, box.v2.y, box.v2.z,0,0,0);
        corners[4] = ImageVector(box.v2.x, box.v1.y, box.v1.z,0,0,0);
        corners[5] = ImageVector(box.v2.x, box.v1.y, box.v2.z,0,0,0);
        corners[6] = ImageVector(box.v2.x, box.v2.y, box.v1.z,0,0,0);
        corners[7] = box.v2;
      }
    }
    ML_CATCH_RETHROW;
  }
  
  
  
#ifdef ML_DEPRECATED
  

  
public:
  
  inline ML_DEPRECATED intT getSize() const { return getNumVoxels(); }
  inline ML_DEPRECATED VectorType getExt() const { return getExtent(); }
  
  
#endif // ML_DEPRECATED  
  
};

#ifdef ML_DEPRECATED




#define TSubImgBox TSubImageBox

#endif // ML_DEPRECATED


ML_END_NAMESPACE

//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std {
  
  template <typename intT>
  inline ostream& operator<<(ostream& s, const ML_NAMESPACE::TSubImageBox<intT> &box)
  {
    return s << box.v1 << " " << box.v2;
  }
  
}


ML_START_NAMESPACE

typedef TSubImageBox<MLint>   SubImageBox;

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef TSubImageBox<MLint16> SubImgBox16;

ML_DEPRECATED typedef TSubImageBox<MLint32> SubImgBox32;

ML_DEPRECATED typedef TSubImageBox<MLint64> SubImgBox64;

ML_DEPRECATED typedef SubImageBox SubImgBox;

#endif // ML_DEPRECATED


//------------------------------------------------------
//   IMPLEMENTATION: Now only internal stuff follows
//------------------------------------------------------

// Swaps all components where v1.* > v2.*. I.e., an empty vector becomes non
// empty if corresponding components are not equal.
template <typename intT>
void TSubImageBox<intT>::correct()
{
  // Move smaller components into v1 and bigger ones into v2
  VectorType V1(v1);
  VectorType V2(v2);
  if (V1.x<V2.x){ v1.x=V1.x; v2.x=V2.x; } else{ v1.x=V2.x; v2.x=V1.x; }
  if (V1.y<V2.y){ v1.y=V1.y; v2.y=V2.y; } else{ v1.y=V2.y; v2.y=V1.y; }
  if (V1.z<V2.z){ v1.z=V1.z; v2.z=V2.z; } else{ v1.z=V2.z; v2.z=V1.z; }
  if (V1.c<V2.c){ v1.c=V1.c; v2.c=V2.c; } else{ v1.c=V2.c; v2.c=V1.c; }
  if (V1.t<V2.t){ v1.t=V1.t; v2.t=V2.t; } else{ v1.t=V2.t; v2.t=V1.t; }
  if (V1.u<V2.u){ v1.u=V1.u; v2.u=V2.u; } else{ v1.u=V2.u; v2.u=V1.u; }
}

// Returns the overlapping region of subimage regions loc1 and loc2.
// A result with (v1.x>v2.x || ... || v1.z>v1.z) is interpreted as empty!
// See also isEmpty(). This is especially true if that already 
// holds for loc1 or loc2.
template <typename intT>
TSubImageBox<intT> TSubImageBox<intT>::intersect(const TSubImageBox<intT> &loc1, const TSubImageBox<intT> &loc2)
{
  ML_TRACE_IN( "TSubImageBox<intT>::intersect( )" );
  
  TSubImageBox<intT> result;
  ML_TRY
  {
    result.v1 = VectorType::compMax(loc1.v1,loc2.v1);
    result.v2 = VectorType::compMin(loc1.v2,loc2.v2);
    return result;
  }
  ML_CATCH_RETHROW;
}

template <typename intT>
TSubImageBox<intT> TSubImageBox<intT>::merge(const TSubImageBox<intT> &loc1, const TSubImageBox<intT> &loc2)
{
  ML_TRACE_IN( "TSubImageBox<intT>::merge( )" );
  
  ML_TRY
  {
    if (loc1.isEmpty()){ return loc2; } else
      if (loc2.isEmpty()){ return loc1; } else
      {
        // Both regions are not empty; determine surrounding box
        // in all dimensions.
        return TSubImageBox<intT>(VectorType::compMin(loc1.v1,loc2.v1),
                                  VectorType::compMax(loc1.v2,loc2.v2));
      }
  }
  ML_CATCH_RETHROW;
}


// Clamps the position pos to the nearest position inside the SubImageBox.
// If the SubImageBox is empty then the result vector contains undefined values.
template <typename intT>
TImageVector<intT> TSubImageBox<intT>::clamp(const VectorType &pos) const
{
  ML_TRACE_IN( "TSubImageBox<intT>::clamp()" );
  
  return VectorType::compMax(VectorType::compMin(pos, v2), v1);
}

ML_END_NAMESPACE

#endif //of __mlSubImageBox_H