albaOBB.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaOBB
 Authors: Marco Petrone
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef __albaOBB_h
#define __albaOBB_h
#include "albaBase.h" 
#include "albaTimeStamped.h"
 
#include "albaDefines.h"
#include "albaMTime.h"
#include "albaMatrix.h"
 
//----------------------------------------------------------------------------
// forward declarations
//----------------------------------------------------------------------------
 
 
class ALBA_EXPORT albaOBB : public albaBase, public albaTimeStamped
{
public:
  albaOBB();
  albaOBB(double source[6]);
  ~albaOBB();
 
  static albaOBB *New() {return new albaOBB;}
 
  bool Equals(float bounds[6]) const;
  bool Equals(double bounds[6]) const;
  bool Equals(albaOBB &bounds) const;
  bool Equals(albaOBB *bounds) {return Equals(*bounds);}
 
 
  bool IsValid() const {return (m_Bounds[0]<=m_Bounds[1] && \
    m_Bounds[2]<=m_Bounds[3] && \
    m_Bounds[4]<=m_Bounds[5]); \
  }
 
  void Reset();
 
  void DeepCopy(double bounds[6]);
  void DeepCopy(float bounds[6]);
  void DeepCopy(albaOBB *);
  void DeepCopy(albaOBB &source) {DeepCopy(&source);}
  void CopyTo(double target[6]) const;
  void CopyTo(float target[6]) const;
 
  void ApplyTransform() {ApplyTransform(m_Matrix,*this);}
 
  void ApplyTransform(albaOBB &newbounds) {ApplyTransform(m_Matrix,newbounds);}
 
  static void ApplyTransform(const albaMatrix &mat, albaOBB &newbounds);
  void ApplyTransform(const albaMatrix &mat) {ApplyTransform(mat,*this);}
 
  void MergeBounds(albaOBB &bounds);
 
  bool IsInside(double point[3]) const;
  bool IsInside(float point[3]) const;
  bool IsInside(double x,double y,double z) const;
 
  static void MergeBounds(double b1[6], double b2[6]);
 
  void GetDimensions(float dims[3]) const;
  void GetDimensions(double dims[3]) const;
 
  void GetCenter(float center[3]) const;
  void GetCenter(double center[3]) const;
 
  void SetCenter(double center[3]);
 
  void SetCenter(float center[3]);
 
  void SetDimensions(double dims[3]);
 
  void SetDimensions(float dims[3]);
 
  double GetWidth() const;
 
  double GetHeight() const;
 
  double GetDepth() const;
 
  void SetOrientation(double rx, double ry, double rz);
 
  void GetOrientation(double rxyz[3]);
 
  virtual void Print(std::ostream& os, const int tabs=0) const;
 
  // member variables are left public to simplify access
 
  albaMatrix m_Matrix; 
  double    m_Bounds[6]; 
};
 
//-------------------------------------------------------------------------
inline bool albaOBB::IsInside(double point[3]) const
//-------------------------------------------------------------------------
{
  return IsInside(point[0],point[1],point[2]);
}
 
//-------------------------------------------------------------------------
inline bool albaOBB::IsInside(float point[3]) const
//-------------------------------------------------------------------------
{
  return IsInside(point[0],point[1],point[2]);
}
 
//-------------------------------------------------------------------------
inline bool albaOBB::IsInside(double x,double y,double z) const
//-------------------------------------------------------------------------
{
  return ((x>=m_Bounds[0])&&(x<=m_Bounds[1])&& \
          (y>=m_Bounds[2])&&(y<=m_Bounds[3])&& \
          (z>=m_Bounds[4])&&(z<=m_Bounds[5]));
}
 
#endif