BoundingBox.C

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 | Library QgarLib, graphics analysis and recognition                  |
 | Copyright (C) 2002  Qgar Project, LORIA                             |
 |                                                                     |
 | This library is free software; you can redistribute it and/or       |
 | modify it under the terms of the GNU Lesser General Public          |
 | License version 2.1, as published by the Free Software Foundation.  |
 |                                                                     |
 | This library is distributed in the hope that it will be useful,     |
 | but WITHOUT ANY WARRANTY; without even the implied warranty of      |
 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                |
 | See the GNU Lesser General Public License for more details.         |
 |                                                                     |
 | The GNU Lesser General Public License is included in the file       |
 | LICENSE.LGPL, in the root directory of the Qgar packaging. See      |
 | http://www.gnu.org/licenses/lgpl.html for the terms of the licence. |
 | To receive a paper copy, write to the Free Software Foundation,     |
 | Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.       |
 |                                                                     |
 | Contact Project Qgar for any information:                           |
 |   LORIA - équipe Qgar                                               |
 |   B.P. 239, 54506 Vandoeuvre-lès-Nancy Cedex, France                |
 |   email: qgar-contact@loria.fr                                      |
 |   http://www.qgar.org/                                              |
 *---------------------------------------------------------------------*/


/**
 * @file   BoundingBox.C
 * @brief  Implementation of class qgar::BoundingBox.
 *
 *         See file BoundingBox.H for the interface.
 * 
 * @author <a href="mailto:qgar-develop@loria.fr?subject=Qgar fwd Gérald Masini">Gérald Masini</a>
 * @date   June 17, 2004  18:46
 * @since  Qgar 2.1.1
 */


// STL
#include <cmath>
#include <iostream>
#include <string>
// QGAR
#include <qgarlib/BoundingBox.H>
#include <qgarlib/primitives.H>
#include <qgarlib/QgarErrorDomain.H>



namespace qgar
{

// -------------------------------------------------------------------
// C O N S T R U C T O R S 
// -------------------------------------------------------------------

  
// DEFAULT CONSTRUCTOR

BoundingBox::BoundingBox()

  : _topLeft    (0, 0),
    _bottomRight(0, 0)

{
  // VOID
}


// COPY CONSTRUCTOR

BoundingBox::BoundingBox(const BoundingBox& aBox)

  : _topLeft    (aBox._topLeft),
    _bottomRight(aBox._bottomRight)

{
  // VOID
}


// INITIALIZE FROM TWO POINTS

BoundingBox::BoundingBox(const IPoint& aPt1,
                         const IPoint& aPt2)
{
   setCorners(aPt1, aPt2);
}


// INITIALIZE FROM COORDINATES OF TWO POINTS

BoundingBox::BoundingBox(int aX1, int aY1, int aX2, int aY2)
{
  setCorners(aX1, aY1, aX2, aY2);
}


// INITIALIZE FROM TOP LEFT CORNER, LENGTH AND HEIGHT

BoundingBox::BoundingBox(const IPoint& aTopLeft,
                         int aLength,
                         int aHeight)
 throw(QgarErrorDomain)

  : _topLeft(aTopLeft),
    _bottomRight(aTopLeft.x() + aLength - 1, 
                 aTopLeft.y() + aHeight - 1)

{
  // Ensure that width and height are greater than 1.
  // Throw exception otherwise.

  if (aLength <= 0) 
    {
      std::ostringstream os;
      os << "Bounding box length ("
         << aLength
         << ") must be greater than 0";
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "qgar::BoundingBox::BoundingBox(const qgar::IPoint&, int, int)",
                            os.str());
    }

  if (aHeight <= 0) 
    {
      std::ostringstream os;
      os << "Bounding box height ("
         << aHeight
         << ") must be greater than 0";
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "qgar::BoundingBox::BoundingBox(const qgar::IPoint&, int, int)",
                            os.str());
    }
}


// INITIALIZE FROM BOTTOM RIGHT CORNER, LENGTH AND HEIGHT

BoundingBox::BoundingBox(int aLength,
                         int aHeight,
                         const IPoint& aBottomRight) 
  throw(QgarErrorDomain)

  : _topLeft(aBottomRight.x() - aLength + 1, 
             aBottomRight.y() - aHeight + 1),
    _bottomRight(aBottomRight)

{
  // Ensure that width and height are greater than 1.
  // Throw exception otherwise.

  if (aLength <= 0) 
    {
      std::ostringstream os;
      os << "Bounding box length ("
         << aLength
         << ") must be greater than 0";
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "qgar::BoundingBox::BoundingBox(int, int, const qgar::IPoint&)",
                            os.str());
    }

  if (aHeight <= 0) 
    {
      std::ostringstream os;
      os << "Bounding box height ("
         << aHeight
         << ") must be greater than 0";
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "qgar::BoundingBox::BoundingBox(int, int, const qgar::IPoint&)",
                            os.str());
    }
}


// -------------------------------------------------------------------
// D E S T R U C T O R
// -------------------------------------------------------------------


BoundingBox::~BoundingBox()
{
  // VOID
}


// -------------------------------------------------------------------
// S E T   C O R N E R S
// -------------------------------------------------------------------


// SET TOP LEFT CORNER

void 
BoundingBox::setTopLeft(const IPoint& aPt)

  throw(QgarErrorDomain)

{
  // Is the new point a valid top left corner?
  if ((aPt.x() > _topLeft.x()) || (aPt.y() > _bottomRight.y()))
    {
      std::ostringstream os;
      os << "New top left corner (" << aPt.x() << ',' << aPt.y()
         << ") does not fit current box: Top left("
         << _topLeft.x() << ',' << _topLeft.y()
         << "), bottom right("
         << _bottomRight.x() << ',' << _bottomRight.y()
         << ')';
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "void qgar::BoundingBox::setTopLeft(const qgar::IPoint&)",
                            os.str());
    }
  _topLeft = aPt;
}


// SET (X AND Y OF) TOP LEFT CORNER

void
BoundingBox::setTopLeft(int aX, int aY)

  throw(QgarErrorDomain)

{
  // Is the new point a valid top left corner?
  if ((aX > _topLeft.x()) || (aY > _bottomRight.y()))
    {
      std::ostringstream os;
      os << "New top left corner (" << aX << ',' << aY
         << ") does not fit current box: Top left("
         << _topLeft.x() << ',' << _topLeft.y()
         << "), bottom right("
         << _bottomRight.x() << ',' << _bottomRight.y()
         << ')';
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "void qgar::BoundingBox::setTopLeft(int, int)",
                            os.str());
    }

  _topLeft.setXY(aX, aY);
}


// SET X COORDINATE OF TOP LEFT CORNER

void
BoundingBox::setXTopLeft(int aX)

  throw(QgarErrorDomain)

{
  // Is the new point a valid top left corner?
  if (aX > _bottomRight.x())
    {
      std::ostringstream os;
      os << "New top left corner (" << aX << ',' << _topLeft.y()
         << ") does not fit current box: Top left("
         << _topLeft.x() << ',' << _topLeft.y()
         << "), bottom right("
         << _bottomRight.x() << ',' << _bottomRight.y()
         << ')';
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "void qgar::BoundingBox::setXTopLeft(int)",
                            os.str());
    }

  _topLeft.setX(aX);
}


// SET Y COORDINATE OF TOP LEFT CORNER

void
BoundingBox::setYTopLeft(int aY)

  throw(QgarErrorDomain)

{
  // Is the new point a valid top left corner?
  if (aY > _bottomRight.y())
    {
      std::ostringstream os;
      os << "New top left corner (" << _topLeft.x() << ',' << aY
         << ") does not fit current box: Top left("
         << _topLeft.x() << ',' << _topLeft.y()
         << "), bottom right("
         << _bottomRight.x() << ',' << _bottomRight.y()
         << ')';
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "void qgar::BoundingBox::setYTopLeft(int)",
                            os.str());
    }

  _topLeft.setY(aY);
}


// SET BOTTOM RIGHT CORNER

void 
BoundingBox::setBottomRight(const IPoint& aPt)

  throw(QgarErrorDomain)

{
  // Is the new point a valid bottom right corner?
  if ((aPt.x() < _topLeft.x()) || (aPt.y() < _bottomRight.y()))
    {
      std::ostringstream os;
      os << "New bottom right corner (" << aPt.x() << ',' << aPt.y()
         << ") does not fit current box: Top left("
         << _topLeft.x() << ',' << _topLeft.y()
         << "), bottom right("
         << _bottomRight.x() << ',' << _bottomRight.y()
         << ')';
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "void qgar::BoundingBox::BottomRight(const qgar::IPoint&)",
                            os.str());
    }
  _bottomRight = aPt;
}


// SET (X AND Y OF) BOTTOM RIGHT CORNER

void
BoundingBox::setBottomRight(int aX, int aY)

  throw(QgarErrorDomain)

{
  // Is the new point a valid bottom right corner?
  if ((aX < _topLeft.x()) || (aY < _bottomRight.y()))
    {
      std::ostringstream os;
      os << "New bottom right corner (" << aX << ',' << aY
         << ") does not fit current box: Top left("
         << _topLeft.x() << ',' << _topLeft.y()
         << "), bottom right("
         << _bottomRight.x() << ',' << _bottomRight.y()
         << ')';
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "void qgar::BoundingBox::setBottomRight(int, int)",
                            os.str());
    }
  _bottomRight.setXY(aX, aY);
}


// SET X COORDINATE OF BOTTOM RIGHT CORNER

void
BoundingBox::setXBottomRight(int aX)

  throw(QgarErrorDomain)

{
  // Is the new point a valid bottom right corner?
  if (aX < _topLeft.x())
    {
      std::ostringstream os;
      os << "New bottom right corner (" << aX << ',' << _bottomRight.y()
         << ") does not fit current box: Top left("
         << _topLeft.x() << ',' << _topLeft.y()
         << "), bottom right("
         << _bottomRight.x() << ',' << _bottomRight.y()
         << ')';
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "void qgar::BoundingBox::setXBottomRight(int)",
                            os.str());
    }

  _bottomRight.setX(aX);
}


// SET Y COORDINATE OF BOTTOM RIGHT CORNER

void
BoundingBox::setYBottomRight(int aY)

  throw(QgarErrorDomain)

{
  // Is the new point a valid bottom right corner?
  if (aY < _topLeft.y())
    {
      std::ostringstream os;
      os << "New bottom right corner (" << _bottomRight.x() << ',' << aY
         << ") does not fit current box: Top left("
         << _topLeft.x() << ',' << _topLeft.y()
         << "), bottom right("
         << _bottomRight.x() << ',' << _bottomRight.y()
         << ')';
      throw QgarErrorDomain(__FILE__, __LINE__,
                            "void qgar::BoundingBox::setYBottomRight(int)",
                            os.str());
    }

  _bottomRight.setY(aY);
}


// SET BOTH TOP LEFT AND BOTTOM RIGHT CORNERS, USING POINTS

void
BoundingBox::setCorners(const IPoint& aPt1, const IPoint& aPt2)
{
  setCorners(aPt1.x(), aPt1.y(), aPt2.x(), aPt2.y());
}


// SET BOTH TOP LEFT AND BOTTOM RIGHT CORNERS, USING COORDINATES

void
BoundingBox::setCorners(int aX1, int aY1, int aX2, int aY2)
{
  // WARNING: THE ORIGIN OF THE COORDINATE SYSTEM
  //          IS AT TOP LEFT OF THE (IMAGE) PLANE
  //   0
  //    +--------------------------------------> X
  //    |
  //    |  top left o--------------+
  //    |           |              |
  //    |           | Bounding Box |
  //    |           |              |
  //    |           +--------------o
  //    |                           bottom right
  //    V
  //
  //    Y

  _topLeft.setXY    ((aX1 > aX2) ? aX2 : aX1, (aY1 > aY2) ? aY2 : aY1);
  _bottomRight.setXY((aX1 > aX2) ? aX1 : aX2, (aY1 > aY2) ? aY1 : aY2);
}


// -------------------------------------------------------------------
// G E O M E T R I C A L   P R E D I C A T E S
// -------------------------------------------------------------------


// DOES THE POINT DEFINED BY THE GIVEN COORDINATES BELONG
// TO THE CURRENT BOUNDING BOX?

bool
BoundingBox::contains(int aX, int aY) const
{
  // WARNING: THE ORIGIN OF THE COORDINATE SYSTEM
  //          IS AT TOP LEFT OF THE (IMAGE) PLANE
  //   0
  //    +--------------------------------------> X
  //    |
  //    |  top left o--------------+
  //    |           |              |
  //    |           | Bounding Box |
  //    |           |              |
  //    |           +--------------o
  //    |                           bottom right
  //    V
  //
  //    Y

  return
       (aX >= _topLeft.x())
    && (aX <= _bottomRight.x())
    && (aY >= _topLeft.y())
    && (aY <= _bottomRight.y());
}


// DOES THE CURRENT BOUNDING BOX INTERSECT THE GIVEN BOUNDING BOX?

bool
BoundingBox::intersects(const BoundingBox& aBox) const
{
  //  0
  //   +-------------------------------> X
  //   |                    |                t: current box top left
  //   |             -------R      T---      r: current box bottom right
  //   |        |             |    |
  //   |      --t-------------+--  |         T: given box top left
  //   |        |/////////////|    |         R: given box bottom right
  //   |   |    |/current box/|
  //   |   |    |/////////////|
  //   |   |  --+-------------r--
  //   | --R    |             |
  //   |
  //   |                     T-------
  //   V                     |
  //   Y
  //
  //  The given box does not intersect the current box iff:
  //
  //  X(R) < X(t)  or  Y(R) < Y(t)  or  X(T) > X(r)  or  Y(T) > Y(r)
  //
  //  => The given box intersects the current box iff:

  return
       (aBox.xBottomRight() >= _topLeft.x())       // X(R) >= X(t)
    && (aBox.yBottomRight() >= _topLeft.y())       // Y(R) >= Y(t)
    && (aBox.xTopLeft()     <= _bottomRight.x())   // X(T) <= X(r)
    && (aBox.yTopLeft()     <= _bottomRight.y());  // Y(T) <= Y(r)
}


// -------------------------------------------------------------------
// G E O M E T R I C A L   O P E R A T I O N S
// -------------------------------------------------------------------


// INTERSECTION BETWEEN THE CURRENT AND GIVEN BOUNDING BOXES

BoundingBox*
BoundingBox::intersection(const BoundingBox& aBox) const
{
  if (this->intersects(aBox))
    {
      // WARNING: THE ORIGIN OF THE COORDINATE SYSTEM
      //          IS AT TOP LEFT OF THE (IMAGE) PLANE
      //   0
      //    +--------------------------------------> X
      //    |
      //    |  top left o--------------+
      //    |           |              |
      //    |           | Bounding Box |
      //    |           |              |
      //    |           +--------------o
      //    |                           bottom right
      //    V
      //
      //    Y

      return
        new BoundingBox(std::max(_topLeft.x(), aBox.xTopLeft()),
                        std::max(_topLeft.y(), aBox.yTopLeft()),
                        std::min(_bottomRight.x(), aBox.xBottomRight()),
                        std::min(_bottomRight.y(), aBox.yBottomRight()));
    }
  else
    {
      return (BoundingBox*)0;
    }
}


// -------------------------------------------------------------------
// O P E R A T O R S
// -------------------------------------------------------------------


// ASSIGNMENT

BoundingBox&
BoundingBox::operator=(const BoundingBox& aBox)
{
  // Are left hand side and right hand side different objects?
  if (this != &aBox)
    {
      _topLeft     = aBox._topLeft;
      _bottomRight = aBox._bottomRight;
    }
  return *this;
}


// -------------------------------------------------------------------
// F U N C T I O N A L   O P E R A T O R S
// -------------------------------------------------------------------


// EQUALITY

bool
BoundingBox::eq(const BoundingBox& aBox) const
{
  return (_topLeft == aBox.topLeft())
    && (_bottomRight == aBox.bottomRight());
}


// INEQUALITY

bool
BoundingBox::notEq(const BoundingBox& aBox) const
{
  return (_topLeft != aBox.topLeft())
    || (_bottomRight != aBox.bottomRight());
}


// -------------------------------------------------------------------
// S E R I A L I Z A T I O N / D E S E R I A L I Z A T I O N
// -------------------------------------------------------------------


std::istream& 
BoundingBox::read(std::istream& anInStream)
{
  IPoint topL;
  IPoint bottomR;
  qgReadObjName(anInStream, "BoundingBox");
  qgReadObjData(anInStream, topL);
  qgReadObjData(anInStream, bottomR);

  setCorners(topL, bottomR);

  return anInStream;
}


std::ostream& 
BoundingBox::write(std::ostream& anOutStream) const
{
  anOutStream << "BoundingBox("
              << _topLeft
              << ")("
              << _bottomRight
              << ')';

  return anOutStream;
}


// -------------------------------------------------------------------


} // namespace qgar