vpRect.h

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2017 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://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * 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 <cassert>
#include <visp3/core/vpException.h>
#include <visp3/core/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 getSize() const { return (this->width * this->height); }

  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;  }

  bool isInside( const vpImagePoint &ip ) const;

  bool operator==(const vpRect &r) const;
  bool operator!=(const vpRect &r) const;
  vpRect& operator&=(const vpRect &r);
  vpRect operator&(const vpRect &r) const;

  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(double left, double top, double width, double height);
  void set(const vpImagePoint &topLeft, double width, double height);
  void set(const vpImagePoint &topLeft, const vpImagePoint &bottomRight);
  void set(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) {
    assert(h > 0);
    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) {
    assert(w > 0);
    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;
  }
  
  inline void moveCenter(const vpImagePoint &center) {
    this->left = center.get_u() - this->width/2  + 0.5;
    this->top  = center.get_v() - 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