rect_2d.h

Go to the documentation of this file.

// -*-c++-*-

 
/*
 *Copyright:
 
 Copyright (C) Hidehisa Akiyama
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */

 
#ifndef RCSC_GEOM_RECT2D_H
#define RCSC_GEOM_RECT2D_H
 
#include <geom/region_2d.h>
#include <geom/size_2d.h>
#include <geom/line_2d.h>
#include <geom/vector_2d.h>
 
namespace rcsc {
 
class Ray2D;
class Segment2D;

class Rect2D
    : public Region2D {
private:
    Vector2D M_top_left;

    Size2D M_size;
 
public:
    Rect2D()
        : M_top_left( 0.0, 0.0 )
        , M_size( 0.0, 0.0 )
      { }
private:
    Rect2D( const double & left_x,
            const double & top_y,
            const double & length,
            const double & width )
        : M_top_left( left_x, top_y )
        , M_size( length, width )
      { }

    Rect2D( const Vector2D & top_left,
            const double & length,
            const double & width )
        : M_top_left( top_left )
        , M_size( length, width )
      { }
 
public:
    Rect2D( const Vector2D & top_left,
            const Size2D & size )
        : M_top_left( top_left )
        , M_size( size )
      { }

    Rect2D( const Vector2D & top_left,
            const Vector2D & bottom_right )
        : M_top_left( top_left )
        , M_size( bottom_right.x - top_left.x,
                  bottom_right.y - top_left.y )
      {
          if ( bottom_right.x - top_left.x < 0.0 )
          {
              M_top_left.x = bottom_right.x;
          }
          if ( bottom_right.y - top_left.y < 0.0 )
          {
              M_top_left.y = bottom_right.y;
          }
      }

    static
    Rect2D from_center( const Vector2D & center,
                        const double & length,
                        const double & width )
      {
          return Rect2D( center.x - length*0.5,
                         center.y - width*0.5,
                         length,
                         width );
      }

    static
    Rect2D from_center( const double & center_x,
                        const double & center_y,
                        const double & length,
                        const double & width )
      {
          return Rect2D( center_x - length*0.5,
                         center_y - width*0.5,
                         length,
                         width );
      }

    static
    Rect2D from_corners( const Vector2D & top_left,
                         const Vector2D & bottom_right )
      {
          return Rect2D( top_left, bottom_right );
      }

    static
    Rect2D from_corners( const double & l,
                         const double & t,
                         const double & r,
                         const double & b )
      {
          return Rect2D( Vector2D( l, t ), Vector2D( r, b ) );
      }
 
private:
    const
    Rect2D & assign( const double & left_x,
                     const double & top_y,
                     const double & length,
                     const double & width )
      {
          M_top_left.assign( left_x, top_y );
          M_size.assign( length, width );
          return *this;
      }

    const
    Rect2D & assign( const Vector2D & top_left,
                     const double & length,
                     const double & width )
      {
          M_top_left = top_left;
          M_size.assign( length, width );
          return *this;
      }
 
public:
    const
    Rect2D & assign( const Vector2D & top_left,
                     const Size2D & size )
      {
          M_top_left = top_left;
          M_size = size;
          return *this;
      }

    const
    Rect2D & moveCenter( const Vector2D & point )
      {
          M_top_left.assign( point.x - M_size.length() * 0.5,
                             point.y - M_size.width() * 0.5 );
          return *this;
      }

    const
    Rect2D & moveTopLeft( const Vector2D & point )
      {
          M_top_left = point;
          return *this;
      }

    const
    Rect2D & moveBottomRight( const Vector2D & point )
      {
          M_top_left.assign( point.x - M_size.length(),
                             point.y - M_size.width() );
          return *this;
      }

    const
    Rect2D & moveLeft( const double & x )
      {
          M_top_left.x = x;
          return *this;
      }

    const
    Rect2D & moveMinX( const double & x )
      {
          return moveLeft( x );
      }

    const
    Rect2D & moveRight( const double & x )
      {
          M_top_left.x = x - M_size.length();
          return *this;
      }

    const
    Rect2D & moveMaxX( const double & x )
      {
          return moveRight( x );
      }

    const
    Rect2D & moveTop( const double & y )
      {
          M_top_left.y = y;
          return *this;
      }

    const
    Rect2D & moveMinY( const double & y )
      {
          return moveTop( y );
      }

    const
    Rect2D & moveBottom( const double & y )
      {
          M_top_left.y = y - M_size.width();
          return *this;
      }

    const
    Rect2D & moveMaxY( const double & y )
      {
          return moveBottom( y );
      }
 

    const
    Rect2D & setTopLeft( const double & x,
                         const double & y );

    const
    Rect2D & setTopLeft( const Vector2D & point )
      {
          return setTopLeft( point.x, point.y );
      }

    const
    Rect2D & setBottomRight( const double & x,
                             const double & y );

    const
    Rect2D & setBottomRight( const Vector2D & point )
      {
          return setBottomRight( point.x, point.y );
      }

    const
    Rect2D & setLeft( const double & x );

    const
    Rect2D & setMinX( const double & x )
      {
          return setLeft( x );
      }

    const
    Rect2D & setRight( const double & x );

    const
    Rect2D & setMaxX( const double & x )
      {
          return setRight( x );
      }

    const
    Rect2D & setTop( const double & y );

    const
    Rect2D & setMinY( const double & y )
      {
          return setTop( y );
      }

    const
    Rect2D & setBottom( const double & y );

    const
    Rect2D & setMaxY( const double & y )
      {
          return setBottom( y );
      }

    const
    Rect2D & setLength( const double & length )
      {
          M_size.setLength( length );
          return *this;
      }

    const
    Rect2D & setWidth( const double & width )
      {
          M_size.setWidth( width );
          return *this;
      }

    const
    Rect2D & setSize( const double & length,
                      const double & width )
      {
          M_size.assign( length, width );
          return *this;
      }

    const
    Rect2D & setSize( const Size2D & size )
      {
          M_size = size;
          return *this;
      }

    bool isValid() const
      {
          return M_size.length() > 0.0
              && M_size.width() > 0.0;
      }

    virtual
    double area() const
      {
          return M_size.length() * M_size.width();
      }

    virtual
    bool contains( const Vector2D & point ) const
      {
          return ( left() <= point.x
                   && point.x <= right()
                   && top() <= point.y
                   && point.y <= bottom() );
      }

    bool contains( const Vector2D & point,
                   const double & error_thr ) const
      {
          return ( left() - error_thr <= point.x
                   && point.x <= right() + error_thr
                   && top() - error_thr <= point.y
                   && point.y <= bottom() + error_thr );
      }

    const
    double & left() const
      {
          return M_top_left.x;
      }

    double right() const
      {
          return left() + size().length();
      }

    const
    double & top() const
      {
          return M_top_left.y;
      }

    double bottom() const
      {
          return top() + size().width();
      }

    double minX() const
      {
          return left();
      }

    double maxX() const
      {
          return right();
      }

    double minY() const
      {
          return top();
      }

    double maxY() const
      {
          return bottom();
      }

    const
    Size2D & size() const
      {
          return M_size;
      }

    Vector2D center() const
      {
          return Vector2D( ( left() + right() ) * 0.5,
                           ( top() + bottom() ) * 0.5 );
      }

    const
    Vector2D & topLeft() const
      {
          return M_top_left;
      }

    Vector2D topRight() const
      {
          return Vector2D( right(), top() );
      }

    Vector2D bottomLeft() const
      {
          return Vector2D( left(), bottom() );
      }

    Vector2D bottomRight() const
      {
          return Vector2D( right(), bottom() );
      }

    Line2D leftEdge() const
      {
          return Line2D( topLeft(), bottomLeft() );
      }

    Line2D rightEdge() const
      {
          return Line2D( topRight(), bottomRight() );
      }

    Line2D topEdge() const
      {
          return Line2D( topLeft(), topRight() );
      }

    Line2D bottomEdge() const
      {
          return Line2D( bottomLeft(), bottomRight() );
      }

    int intersection( const Line2D & line,
                      Vector2D * sol1,
                      Vector2D * sol2 ) const;

    int intersection( const Ray2D & ray,
                      Vector2D * sol1,
                      Vector2D * sol2 ) const;

    int intersection( const Segment2D & segment,
                      Vector2D * sol1,
                      Vector2D * sol2 ) const;

    const
    Rect2D & operator&=( const Rect2D & other );

    Rect2D intersected( const Rect2D & other ) const
      {
          return Rect2D( *this ) &= other;
      }

    const
    Rect2D & operator|=( const Rect2D & other );

    Rect2D united( const Rect2D & other ) const
      {
          return Rect2D( *this ) |= other;
      }
};

inline
const
rcsc::Rect2D
operator&( const rcsc::Rect2D & lhs,
           const rcsc::Rect2D & rhs )
{
    return rcsc::Rect2D( lhs ) &= rhs;
}

inline
const
rcsc::Rect2D
operator|( const rcsc::Rect2D & lhs,
           const rcsc::Rect2D & rhs )
{
    return rcsc::Rect2D( lhs ) |= rhs;
}
 
}
 
#endif