vpRect.h

/****************************************************************************
 *
 * $Id: vpRect.h 4649 2014-02-07 14:57:11Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2014 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * Defines a rectangle in the plane.
 *
 * Author:
 * Fabien Spindler
 *
 *****************************************************************************/


#ifndef vpRect_h
#define vpRect_h




#include <vector>
#include <visp/vpException.h>
#include <visp/vpImagePoint.h>


class VISP_EXPORT vpRect
{
public:

  vpRect();
  vpRect(double left, double top, double width, double height);
  vpRect(const vpImagePoint &topLeft, double width, double height);
  vpRect(const vpImagePoint &topLeft, const vpImagePoint &bottomRight);
  vpRect(const vpRect& r);
  vpRect(const std::vector<vpImagePoint> &ip);

  
  vpRect &operator=(const vpRect& r);

  inline double getBottom() const { return (this->top + this->height - 1.0); };
  inline vpImagePoint getBottomRight() const {
    vpImagePoint bottomRight;
    bottomRight.set_u( getRight() );
    bottomRight.set_v( getBottom() );

    return bottomRight;
  };
  inline void getCenter(double & x, double & y) const { 
    x = this->left + this->width  / 2.0 - 0.5; 
    y = this->top  + this->height / 2.0 - 0.5; 
  };
  inline vpImagePoint getCenter() const { 
    vpImagePoint center;
    center.set_u( this->left + this->width  / 2.0 - 0.5 ); 
    center.set_v( this->top  + this->height / 2.0 - 0.5 ); 
    return center;
  };
  inline double getHeight() const { return this->height; };
  inline double getLeft() const { return this->left;   };

  inline double getRight() const { return (this->left + this->width - 1.0); };

  inline double getTop() const { return this->top;  };
  inline vpImagePoint getTopLeft() const { 
    vpImagePoint topLeft;
    topLeft.set_u( this->left );
    topLeft.set_v( this->top );
    return topLeft; 
  };
  inline double getWidth() const { return this->width;  };

  friend VISP_EXPORT bool inRectangle( const vpImagePoint &ip, const vpRect &rect );
  friend VISP_EXPORT std::ostream& operator<< (std::ostream &os, const vpRect& r);
  void set(const std::vector<vpImagePoint> &ip);

  inline void setBottom(double pos) { this->height = pos - this->top + 1.0; };
  inline void setBottomRight(const vpImagePoint &bottomRight) {
    this->height = bottomRight.get_v() - this->top + 1.0; 
    this->width = bottomRight.get_u() - this->left + 1.0;
  };
  inline void setHeight(double h) { this->height = h; };
  inline void setLeft(double pos) { this->left = pos; };
  inline void setRect(double l, double t, double w, double h) {
     this->left   = l;
     this->top    = t;
     this->width  = w;
     this->height = h;
  };
  inline void setRight(double pos) { this->width = pos - this->left + 1.0; };
  inline void setTop(double pos) { this->top = pos; };
  inline void setTopLeft(const vpImagePoint &topLeft) { 
    this->left = topLeft.get_u(); 
    this->top  = topLeft.get_v(); 
  };
  inline void setWidth(double w) { this->width = w; }
 
  inline void moveCenter(double x, double y) {
    this->left = x - this->width/2  + 0.5;
    this->top  = y - this->height/2 + 0.5;
  };
  
private:
  double left;   // Upper left corner position along the columns axis
  double top;    // Upper left corner position along the rows axis
  double width;  // Rectangle width
  double height; // Rectangle height
};

#endif