Rect32f.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/Rect32f.h                        **
** Module : ICLUtils                                               **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** 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/CompatMacros.h>
#include <ICLUtils/Point32f.h>
#include <ICLUtils/Size32f.h>
#include <ICLUtils/Rect.h>
#include <stdio.h>
#include <algorithm>

namespace icl {
  namespace utils{
    
    
    class ICLUtils_API Rect32f{
      public:
     
      float x;      
      float y;      
      float width;  
      float height; 
  
      static const Rect32f null;

            Rect32f(){
                    this->x = 0.0f;
                    this->y = 0.0f;
                    this->width = 0.0f;
                    this->height = 0.0f;
            }

      Rect32f(float x, float y, float width, float height):
      x(x),y(y),width(width),height(height){
        this->x = x;
        this->y = y;
        this->width = width;
        this->height = height;
      }
      
      Rect32f(const Point32f &p, const Size32f &s){
        this->x = p.x;
        this->y = p.y;
        this->width = s.width;
        this->height = s.height;
      } 
      
      Rect32f(const Rect32f &r){
        this->x = r.x;
        this->y = r.y;
        this->width = r.width;
        this->height = r.height;
      }
      
      Rect32f(const Rect &rect):
        x((float)rect.x),
        y((float)rect.y),
        width((float)rect.width),
        height((float)rect.height){
      }
  
      bool isNull() const { return (*this)==null; }
  
      bool operator==(const Rect32f &s) const {
        return x==s.x && y==s.y && width==s.width && height==s.height;
      }
  
      bool operator!=(const Rect32f &s) const {
        return x!=s.x || y!= s.y || width!=s.width || height!=s.height;
      }
  
      Rect32f operator*(double d) const {
        return Rect32f(d*x,d*y,d*width,d*height);
      }
  
      Rect32f operator/(double d) const {
        return Rect32f(d/x,d/y,d/width,d/height);
      }
  
      Rect32f& operator+=(const Size32f &s){
        width+=s.width; height+=s.height; return *this;
      }
      
      Rect32f& operator-=(const Size32f &s){
        width-=s.width; height-=s.height; return *this;
      }
      
      Rect32f& operator+=(const Point32f &p){
        x+=p.x; y+=p.y; return *this;
      }
  
      Rect32f& operator-=(const Point32f &p){
        x-=p.x; y-=p.y; return *this;
      }
      
      Rect32f& operator*=(double d){
        x*=d;
        y*=d;
        width*=d;
        height*=d;
        return *this;
      }
      Rect32f& operator/=(double d){
        x/=d;
        y/=d;
        width/=d;
        height/=d;
        return *this;
      }
      float getDim() const {return width*height;}
  
      Rect32f operator&(const Rect32f &r) const {
         Point32f ul (iclMax (x, r.x), iclMax (y, r.y));
         Point32f lr (iclMin (right(), r.right()), iclMin (bottom(), r.bottom()));
         Rect32f 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;
      }
      
      Rect32f &operator&=(const Rect32f &r){
        (*this)=(*this)&r;
        return *this;
      }
      
      Rect32f operator|(const Rect32f &r) const {
         Point32f ul (iclMin (x, r.x), iclMin (y, r.y));
         Point32f lr (iclMax (right(), r.right()), iclMax (bottom(), r.bottom()));
         return Rect32f (ul.x, ul.y, lr.x-ul.x, lr.y-ul.y);
      }
  
      Rect32f &operator|=(const Rect32f &r){
        (*this)=(*this)|r;
        return *this;
      }
      

      Rect32f normalized() const {
         Rect32f 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 Rect32f &r) const {
         return x<=r.x && y <= r.y && right() >= r.right() && bottom() >= r.bottom();
      }
      
      bool contains(float x, float y) const{
        return this->x<=x && right()>=x && this->y<=y && bottom()>=y;
      }
      

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

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