Rect.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLUtils/src/ICLUtils/Rect.h                           **
** Module : ICLUtils                                               **
** Authors: Christof Elbrechter, Robert Haschke                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/Macros.h>
#include <ICLUtils/Point.h>
#include <ICLUtils/Size.h>
#include <stdio.h>
#include <algorithm>
#ifdef ICL_HAVE_IPP
#include <ipp.h>
#endif


namespace icl {
  namespace utils{
    
  #ifndef ICL_HAVE_IPP

    struct IppiRect {
  
      int x;
      
      int y;
  
      int width;
  
      int height;
    };
  #else
  #endif
    

    class Rect32f;
    class ICLUtils_API Rect : public IppiRect{
      public:
      
      static const Rect null;

            Rect(){
                    this->x = 0;
                    this->y = 0;
                    this->width = 0;
                    this->height = 0;
            }

      Rect(int x, int y, int width, int height){
        this->x = x;
        this->y = y;
        this->width = width;
        this->height = height;
      }
      
      Rect(const Point &p, const Size &s){
        this->x = p.x;
        this->y = p.y;
        this->width = s.width;
        this->height = s.height;
      } 
      
      Rect(const Rect &r){
        this->x = r.x;
        this->y = r.y;
        this->width = r.width;
        this->height = r.height;
      }
  
      Rect(const Rect32f &other);
  
      bool isNull() const { return (*this)==null; }
  
      bool operator==(const Rect &s) const {
        return x==s.x && y==s.y && width==s.width && height==s.height;
      }
  
      bool operator!=(const Rect &s) const {
        return x!=s.x || y!= s.y || width!=s.width || height!=s.height;
      }
  
      Rect operator*(double d) const {
        return Rect((int)(d*x),(int)(d*y),(int)(d*width),(int)(d*height));
      }
  
      Rect operator/(double d) const {
        return Rect((int)(x/d),(int)(y/d),(int)(width/d),(int)(height/d));
      }
  
     
      Rect operator+(const Size &s) const{
        return Rect(x,y,width+s.width,height+s.height);
      }
  
      Rect operator-(const Size &s) const{
        return Rect(x,y,width-s.width,height-s.height);
      }
      
      Rect& operator+=(const Size &s){
        width+=s.width; height+=s.height; return *this;
      }
  
      Rect& operator-=(const Size &s){
        width-=s.width; height-=s.height; return *this;
      }
      
      Rect operator+(const Point &p) const{
        return Rect(x+p.x,y+p.y,width,height);
      }
  
      Rect operator-(const Point &p) const{
        return Rect(x-p.x,y-p.y,width,height);
      }
      
      Rect& operator+=(const Point &p){
        x+=p.x; y+=p.y; return *this;
      }
  
      Rect& operator-=(const Point &p){
        x-=p.x; y-=p.y; return *this;
      }
      
      Rect& operator*=(double d){
        x=(int)((float)x*d); 
        y=(int)((float)y*d);
        width=(int)((float)width*d); 
        height=(int)((float)height*d); 
        return *this;
      }
      Rect& operator/=(double d){
        x=(int)((float)x/d); 
        y=(int)((float)y/d);
        width=(int)((float)width/d); 
        height=(int)((float)height/d); 
        return *this;
      }
      int getDim() const {return width*height;}

      Rect operator&(const Rect &r) const {
         Point ul (iclMax(x, r.x), iclMax(y, r.y));
         Point lr (iclMin(right(), r.right()), iclMin(bottom(), r.bottom()));
         Rect result (ul.x, ul.y, lr.x-ul.x, lr.y-ul.y);
         if (result.width > 0 && result.height > 0) return result;
         else return null;
      }

      Rect &operator&=(const Rect &r){
        (*this)=(*this)&r;
        return *this;
      }

      Rect operator|(const Rect &r) const {
         Point ul (iclMin(x, r.x), iclMin(y, r.y));
         Point lr (iclMax(right(), r.right()), iclMax(bottom(), r.bottom()));
         return Rect (ul.x, ul.y, lr.x-ul.x, lr.y-ul.y);
      }

      Rect &operator|=(const Rect &r){
        (*this)=(*this)|r;
        return *this;
      }
      

      Rect normalized() const {
         Rect r (*this);
         if (r.width < 0) {r.x += r.width; r.width = -r.width; }
         if (r.height < 0) {r.y += r.height; r.height = -r.height; }
         return r;
      }
      
      bool contains(const Rect &r) const {
         return x<=r.x && y <= r.y && right() >= r.right() && bottom() >= r.bottom();
      }
      

      bool contains(int x, int y) const{
        return this->x<=x && right()>x && this->y<=y && bottom()>y;
      }
  

      Rect &enlarge(int k){
        x-=k; y-=k; width+=2*k; height+=2*k;
        return *this;
      }
      

      Rect enlarged(int k) const{
        return Rect(*this).enlarge(k);
      }
      
      
      Point ul() const {
        return Point(x,y);
      }
      Point ll() const {
        return Point(x,y+height);
      }
      Point ur() const {
        return Point(x+width,y);
      }
      Point lr() const {
        return Point(x+width,y+height);
      }
  
      Point center() const {
        return Point(x+width/2,y+height/2);
      }
      
      int left() const { return x; }
  
      int right() const { return x+width; }
  
      int bottom() const { return y+height; }
  
      int top() const { return y; }
  
      Size getSize() const { return Size(width,height); }
  
      Rect transform(double xfac, double yfac) const { 
        return Rect((int)(xfac*x),(int)(yfac*y),(int)(xfac*width), (int)(yfac*height)); 
      }
    };
  
    ICLUtils_API std::ostream &operator<<(std::ostream &s, const Rect &r);
    
    ICLUtils_API std::istream &operator>>(std::istream &s, Rect &r);
  
  
  } // namespace utils
} // namespace icl