vpRect.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2019 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 as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 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 <algorithm>
#include <cassert>
#include <vector>
#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);
  explicit vpRect(const std::vector<vpImagePoint> &ip);
 
  inline double getArea() const { return width * height; }
 
  inline double getBottom() const { return (this->top + this->height - 1.0); }
 
  inline vpImagePoint getBottomLeft() const
  {
    vpImagePoint bottomLeft;
    bottomLeft.set_u(getLeft());
    bottomLeft.set_v(getBottom());
    return bottomLeft;
  }
 
  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(getLeft());
    topLeft.set_v(getTop());
    return topLeft;
  }
 
  inline vpImagePoint getTopRight() const
  {
    vpImagePoint topRight;
    topRight.set_u(getRight());
    topRight.set_v(getTop());
    return topRight;
  }
 
  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;
 
  inline vpRect &operator&=(const vpRect &r)
  {
    double x1 = (std::max)(left, r.left);
    double y1 = (std::max)(top, r.top);
    width = (std::min)(left + width, r.left + r.width) - x1;
    height = (std::min)(top + height, r.top + r.height) - y1;
    left = x1;
    top = y1;
 
    if (width <= 0 || height <= 0) {
      *this = vpRect();
    }
 
    return *this;
  }
 
  vpRect &operator=(const vpRect &r);
 
  inline vpRect operator&(const vpRect &r) const
  {
    vpRect a = *this;
    return a &= r;
  }
 
  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