box3.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: box3.h,v 1.46 2005/12/23 17:01:48 amoll Exp $
//

#ifndef BALL_MATHS_BOX3_H
#define BALL_MATHS_BOX3_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#ifndef BALL_MATHS_VECTOR3_H
# include <BALL/MATHS/vector3.h>
#endif

namespace BALL 
{

  template <typename T>
  class TBox3
  {
    public:

    BALL_CREATE(TBox3<T>)

    

    TBox3();

    TBox3(const TBox3& box);

    TBox3(const TVector3<T>& point, 
          const TVector3<T>& right_vector  = TVector3<T>((T) 0, (T)1, (T)0),
          const TVector3<T>& height_vector = TVector3<T>((T)-1, (T)0, (T)0),
          const T& depth = 1);

    virtual ~TBox3()
    {
    }

    virtual void clear();



    void set(const TBox3& box);

    const TBox3& operator = (const TBox3& box);

    void swap(TBox3& box);


    
    void setWidth(T width);

    T getWidth() const { return width_;}

    void setHeight(T height) ;
    
    T getHeight() const { return height_;}

    void setDepth(T depth)  { depth_ = depth;}

    T getDepth() const { return depth_;}

    const TVector3<T>& getPoint() const { return point_;}

    void setPoint(const TVector3<T>& point)  { point_ = point;}

    const TVector3<T>& getRightVector() const { return right_vector_;}

    void setRightVector(const TVector3<T>& v);

    const TVector3<T>& getHeightVector() const { return height_vector_;}
    
    void setHeightVector(const TVector3<T>& v);

    T getSurface() const;

    T getVolume() const;

    TVector3<T> getDiagonalVector() const;



    bool operator == (const TBox3& box) const;

    bool operator != (const TBox3& box) const;

    /*  Test if a given point is a member of the box.
        Optional it can be testet, if the point lies on the surface.
        @param point the point to be tested
        @param on_surface true to test the surface (default = false)
        @return bool, <b>true</b> or <b>false</b>
    */
    //bool has(const TVector3<T>& point, bool on_surface = false) const;

    /*  Test if two boxes intersect.
        @param box the box to be tested
        @return bool, <b>true</b> if the two boxes are intersecting, <b>false</b> otherwise
    */
    //bool isIntersecting(const TBox3& box) const;
  


    bool isValid() const;

    void dump(std::ostream& s = std::cout, Size depth = 0) const;

    protected:

    //_ lower left point of the box.
    TVector3<T> point_;
    TVector3<T> right_vector_;
    TVector3<T> height_vector_;

    T width_;
    T height_;
    T depth_;
  };


  template <typename T>
  TBox3<T>::TBox3(const TVector3<T>& point, const TVector3<T>& right_vector,const TVector3<T>& height_vector,const T& depth)
    : point_(point),
      right_vector_(right_vector),
      height_vector_(height_vector),
      width_(right_vector.getLength()),
      height_(height_vector.getLength()),
      depth_(depth)
  {}

  template <typename T>
  TBox3<T>::TBox3()
    : point_((T)0, (T)0, (T)0),
      right_vector_((T)0, (T)1, (T)0),
      height_vector_((T)-1, (T)0, (T)0),
      width_((T)1),
      height_((T)1),
      depth_((T)1)
  {
  }

  template <typename T>
  TBox3<T>::TBox3(const TBox3<T>& box)
    : point_(box.point_),
      right_vector_(box.right_vector_),
      height_vector_(box.height_vector_),
      width_(box.width_),
      height_(box.height_),
      depth_(box.depth_)
  {
  }

  template <typename T>
  void TBox3<T>::set(const TBox3<T>& box)
  {
    point_ = box.point_;
    right_vector_ = box.right_vector_;
    height_vector_ = box.height_vector_;
    width_ = box.width_;
    height_ = box.height_;
    depth_ = box.depth_;
  }

  template <typename T>
  BALL_INLINE
  const TBox3<T>& TBox3<T>::operator = (const TBox3<T> &box)
  {
    set(box);
    return *this;
  }

  template <typename T>
  void TBox3<T>::swap(TBox3<T>& box)
  {
    point_.swap(box.point_);
    right_vector_.swap(box.right_vector_);
    height_vector_.swap(box.height_vector_);

    std::swap(width_, box.width_);
    std::swap(height_, box.height_);
    std::swap(depth_, box.depth_);
  }

  template <typename T>
  void TBox3<T>::clear()
  {
    point_.clear();
    right_vector_ = TVector3<T>((T)0, (T)1, (T)0);
    height_vector_ = TVector3<T>((T)-1, (T)0, (T)0);
    width_ = (T) 1;
    height_ = (T) 1;
    depth_  = (T) 1;
  }
  

  template <typename T>
  BALL_INLINE
  void TBox3<T>::setWidth(T width) 
  {
    right_vector_.normalize();
    right_vector_ *= width;
    width_ = width;
  }

  template <typename T>
  BALL_INLINE
  void TBox3<T>::setHeight(T height)
  {
    height_vector_.normalize();
    height_vector_ *= height;
    height_ = height;
  }

  template <typename T>
  BALL_INLINE
  void TBox3<T>::setRightVector(const TVector3<T>& v)
  {
    right_vector_ = v;
    width_ = right_vector_.getLength();
  }

  template <typename T>
  BALL_INLINE
  void TBox3<T>::setHeightVector(const TVector3<T>& v)
  {
    height_vector_ = v;
    height_ = height_vector_.getLength();
  }

  template <typename T>
  BALL_INLINE 
  T TBox3<T>::getSurface() const
  {
    return ((width_  * height_ + width_  * depth_  + height_ * depth_) * 2);
  }

  template <typename T>
  TVector3<T> TBox3<T>::getDiagonalVector() const
  {
    TVector3<T> v = right_vector_ % height_vector_;
    v.normalize();
    v *= depth_;
    return (v + right_vector_ + height_vector_);
  }

  template <typename T>
  BALL_INLINE 
  T TBox3<T>::getVolume() const
  {
    return (width_ * height_ * depth_);
  }

  template <typename T>
  bool TBox3<T>::operator == (const TBox3<T>& box) const
  {
    return (point_ == box.point_ && right_vector_ == box.right_vector_ && height_vector_ == box.height_vector_ &&width_ == box.width_ && height_ == box.height_ && depth_ == box.depth_);
  }

  template <typename T>
  BALL_INLINE 
  bool TBox3<T>::operator != (const TBox3<T> &box) const
  {
    return !(*this == box);
  }

  template <typename T>
  BALL_INLINE 
  bool TBox3<T>::isValid() const
  {
    return (point_.isValid() && 
            right_vector_.isValid() &&
            height_vector_.isValid() &&
            !right_vector_.isZero() &&
            !height_vector_.isZero() && 
            right_vector_.isOrthogonalTo(height_vector_));
            
  }

  template <typename T>
  void TBox3<T>::dump(std::ostream& s, Size depth) const
  {
    BALL_DUMP_STREAM_PREFIX(s);
    
    BALL_DUMP_HEADER(s, this, this);
    
    BALL_DUMP_DEPTH(s, depth);
    s << "point: " << point_ << std::endl;
    
    BALL_DUMP_DEPTH(s, depth);
    s << "right_vector: " << right_vector_ << std::endl;

    BALL_DUMP_DEPTH(s, depth);
    s << "height_vector: " << height_vector_ << std::endl;

    BALL_DUMP_DEPTH(s, depth);
    s << "width: " << width_ << std::endl;
    
    BALL_DUMP_DEPTH(s, depth);
    s << "height: " << height_ << std::endl;
    
    BALL_DUMP_DEPTH(s, depth);
    s << "depth: " << depth_ << std::endl;
    
    BALL_DUMP_STREAM_SUFFIX(s);
  }

  template <typename T>
  std::istream& operator >> (std::istream& s, TBox3<T>& box)
  {
    TVector3<T> point, right, height;
    T depth;
    s >> point >> right >> height >> depth;
    box.setPoint(point);
    box.setRightVector(right);
    box.setHeightVector(height);
    box.setDepth(depth);
    return s;
  }

  template <typename T>
  std::ostream& operator << (std::ostream& s, const TBox3<T>& box)
  {
    return s << box.getPoint() << " " << box.getRightVector() << " " << box.getHeightVector() << " " << box.getDepth();
  }

  typedef TBox3<float> Box3;

} // namespace BALL

#endif // BALL_MATHS_BOX3_H