BBox.hxx

/*--------------------------------------------------------------------------*\
 |                                                                          |
 |  Copyright (C) 2018                                                      |
 |                                                                          |
 |         , __                 , __                                        |
 |        /|/  \               /|/  \                                       |
 |         | __/ _   ,_         | __/ _   ,_                                |
 |         |   \|/  /  |  |   | |   \|/  /  |  |   |                        |
 |         |(__/|__/   |_/ \_/|/|(__/|__/   |_/ \_/|/                       |
 |                           /|                   /|                        |
 |                           \|                   \|                        |
 |                                                                          |
 |      Paolo Bevilacqua and Enrico Bertolazzi                              |
 |                                                                          |
 |      (1) Dipartimento di Ingegneria e Scienza dell'Informazione          |
 |      (2) Dipartimento di Ingegneria Industriale                          |
 |                                                                          |
 |      Università degli Studi di Trento                                    |
 |      email: paolo.bevilacqua@unitn.it                                    |
 |      email: enrico.bertolazzi@unitn.it                                   |
 |                                                                          |
\*--------------------------------------------------------------------------*/
 
 
namespace G2lib {
 
  using std::setw;
  using std::vector;
  using std::pair;
 
  using std::make_shared;
  using std::shared_ptr; // promemoria shared_ptr<Foo>(&foo, [](void*){});
 
  /*\
   |   ____  ____
   |  | __ )| __ )  _____  __
   |  |  _ \|  _ \ / _ \ \/ /
   |  | |_) | |_) | (_) >  <
   |  |____/|____/ \___/_/\_\
  \*/
  class BBox {
  public:
    using PtrBBox        = shared_ptr<BBox const>;
    using PairPtrBBox    = pair<PtrBBox,PtrBBox>;
    using VecPtrBBox     = vector<PtrBBox>;
    using VecPairPtrBBox = vector<PairPtrBBox>;
 
  private:
    real_type m_bbox[4]{0,0,0,0}; 
    integer   m_id{0};            
    integer   m_ipos{0};          
 
    BBox();
 
    BBox( BBox const & ) = default;
    BBox( BBox && ) = default;
 
  public:
 
    BBox(
      real_type xmin,
      real_type ymin,
      real_type xmax,
      real_type ymax,
      integer   id,
      integer   ipos
    ) {
      m_bbox[0] = xmin;
      m_bbox[1] = ymin;
      m_bbox[2] = xmax;
      m_bbox[3] = ymax;
      m_id      = id;
      m_ipos    = ipos;
    }
 
    BBox(
      real_type const bbox[4],
      integer         id,
      integer         ipos
    ) {
      std::copy_n( bbox, 4, m_bbox );
      m_id   = id;
      m_ipos = ipos;
    }
 
    BBox(
      real_type const bbox_min[2],
      real_type const bbox_max[2],
      integer         id,
      integer         ipos
    ) {
      std::copy_n( bbox_min, 2, m_bbox   );
      std::copy_n( bbox_max, 2, m_bbox+2 );
      m_id   = id;
      m_ipos = ipos;
    }
 
    BBox(
      vector<PtrBBox> const & bboxes,
      integer                 id,
      integer                 ipos
    ) {
      m_id   = id;
      m_ipos = ipos;
      this -> join( bboxes );
    }
 
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
    real_type const * bbox()     { return m_bbox; }
    real_type const * bbox_min() { return m_bbox; }
    real_type const * bbox_max() { return m_bbox+2; }
 
    real_type & x_min() { return m_bbox[0]; } 
    real_type & y_min() { return m_bbox[1]; } 
    real_type & x_max() { return m_bbox[2]; } 
    real_type & y_max() { return m_bbox[3]; } 
 
    real_type const & x_min() const { return m_bbox[0]; } 
    real_type const & y_min() const { return m_bbox[1]; } 
    real_type const & x_max() const { return m_bbox[2]; } 
    real_type const & y_max() const { return m_bbox[3]; } 
 
    integer const & Id()   const { return m_id; }   
    integer const & Ipos() const { return m_ipos; } 
 
    BBox const &
    operator = ( BBox const & rhs ) {
      std::copy_n( rhs.m_bbox, 4, m_bbox );
      m_id   = rhs.m_id;
      m_ipos = rhs.m_ipos;
      return *this;
    }
 
    bool
    collision( BBox const & box ) const {
      return !( (box.x_min() > this->x_max() ) ||
                (box.x_max() < this->x_min() ) ||
                (box.y_min() > this->y_max() ) ||
                (box.y_max() < this->y_min() ) );
    }
 
    void
    join( vector<PtrBBox> const & bboxes );
 
    real_type
    distance( real_type x, real_type y ) const;
 
    real_type
    max_distance( real_type x, real_type y ) const;
 
    void print( ostream_type & stream ) const;
 
  };
 
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  inline
  ostream_type &
  operator << ( ostream_type & stream, BBox const & bb ) {
    bb.print(stream);
    return stream;
  }
 
}