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 <rcsc/geom/region_2d.h>
#include <rcsc/geom/size_2d.h>
#include <rcsc/geom/line_2d.h>
#include <rcsc/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 );
      }
 
    double left() const
      {
          return M_top_left.x;
      }
 
    double right() const
      {
          return left() + size().length();
      }
 
    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