mlSubImageBox.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, 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_SUB_IMAGE_BOX_H
#define ML_SUB_IMAGE_BOX_H
 
 
//ML-includes
#include "mlInitSystemML.h"
#include "mlImageVector.h"
 
ML_START_NAMESPACE
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
template<typename intT> class TSubImageBox
{
 
public:
  typedef TImageVector<intT> VectorType;
 
  VectorType v1;
 
  VectorType v2;
 
  //------------------------------------------------------
  //------------------------------------------------------
  inline TSubImageBox() : v1(0), v2(-1)
  {
  }
 
  inline TSubImageBox(const VectorType& vector1, const VectorType& vector2) : v1(vector1), v2(vector2)
  {
  }
 
  inline TSubImageBox(const VectorType extent) : v1(0), v2(extent-1)
  {
  }
 
 
 
  //------------------------------------------------------
  //------------------------------------------------------
  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
  {
    if (isEmpty())
    {
      return 0;
    }
    else
    {
      return VectorType::compMul((v2-v1)+VectorType(1));
    }
  }
 
  VectorType getExtent() const
  {
    if (isEmpty())
    {
      return VectorType(0);
    }
    else
    {
      return (v2-v1)+VectorType(1);
    }
  }
 
 
  void correct();
 
 
 
  //------------------------------------------------------
  //------------------------------------------------------
  [[nodiscard]]
  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()
  {
    v1.set(0);
    v2.set(-1);
  }
 
  [[nodiscard]]
  TSubImageBox<intT> intersect(const TSubImageBox<intT>& box) const
  {
    return TSubImageBox<intT>::intersect(*this, box);
  }
 
  [[nodiscard]]
  TSubImageBox<intT> merge(const TSubImageBox<intT>& box) const
  {
    return TSubImageBox<intT>::merge(*this, box);
  }
 
  VectorType clamp(const VectorType& position) const;
 
  inline bool contains (const VectorType& position) const
  {
    return (position >= v1) && (position <= v2);
  }
 
  inline void translate(const VectorType& offsetVector)
  {
    v1 = v1+offsetVector;
    v2 = v2+offsetVector;
  }
 
  static void get3DCorners(const TSubImageBox<intT>& box, VectorType corners[8])
  {
    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;
    }
  }
 
 
 
#if ML_DEPRECATED_SINCE(3,5,0)
 
 
public:
 
  inline ML_DEPRECATED intT getSize() const { return getNumVoxels(); }
  inline ML_DEPRECATED VectorType getExt() const { return getExtent(); }
 
 
#endif
 
};
 
#if ML_DEPRECATED_SINCE(3,5,0)
#define TSubImgBox TSubImageBox
#endif
 
 
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;
 
#if ML_DEPRECATED_SINCE(3,5,0)
ML_DEPRECATED typedef TSubImageBox<MLint16> SubImgBox16;
 
ML_DEPRECATED typedef TSubImageBox<MLint32> SubImgBox32;
 
ML_DEPRECATED typedef TSubImageBox<MLint64> SubImgBox64;
 
ML_DEPRECATED typedef SubImageBox SubImgBox;
 
#endif
 
 
//------------------------------------------------------
//   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)
{
  TSubImageBox<intT> result;
  result.v1 = VectorType::compMax(loc1.v1,loc2.v1);
  result.v2 = VectorType::compMin(loc1.v2,loc2.v2);
  return result;
}
 
template <typename intT>
TSubImageBox<intT> TSubImageBox<intT>::merge(const TSubImageBox<intT> &loc1, const TSubImageBox<intT> &loc2)
{
  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));
    }
}
 
 
// 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
{
  return VectorType::compMax(VectorType::compMin(pos, v2), v1);
}
 
ML_END_NAMESPACE
 
#endif //of __mlSubImageBox_H