cell2d.h

/*
 * Orca-Robotics Project: Components for robotics 
 *               http://orca-robotics.sf.net/
 * Copyright (c) 2004-2009 Alex Brooks, Alexei Makarenko, Tobias Kaupp
 *
 * This copy of Orca is licensed to you under the terms described in
 * the LICENSE file included in this distribution.
 *
 */

#ifndef ORCA2_CELL2D_H
#define ORCA2_CELL2D_H

#include <iostream>
#include <vector>
#include <list>

namespace hydropathplan
{

    class Cell2D
    {
    public:
        Cell2D( int x=0, int y=0);
        ~Cell2D() {};

        int x() const;
        int y() const;

        void setX( const int x);
        void setY( const int y);
        void set( const int x, const int y);

        Cell2D & operator= ( const Cell2D & p );// { x_=p.x_; y_=p.y_; return *this; };
        Cell2D & operator+= ( const Cell2D & );
        Cell2D & operator-= ( const Cell2D & );
        Cell2D & operator*= ( int );
        Cell2D & operator/= ( int );

        friend inline bool    operator== ( const Cell2D &, const Cell2D & );
        friend inline bool    operator!= ( const Cell2D &, const Cell2D & );
        friend inline const Cell2D operator+ ( const Cell2D &, const Cell2D & );
        friend inline const Cell2D operator- ( const Cell2D &, const Cell2D & );
        friend inline const Cell2D operator* ( const Cell2D &, int );
        friend inline const Cell2D operator* ( int, const Cell2D & );
        friend inline const Cell2D operator- ( const Cell2D & );
    private:
        int x_;
        int y_;
    };

    typedef std::vector<hydropathplan::Cell2D> Cell2DVector;
    typedef std::list<hydropathplan::Cell2D> Cell2DList;

    bool isIncluded( const Cell2DVector & C, const Cell2D & c );
    bool isIncluded( const Cell2DList & C, const Cell2D & c );
    

    /*****************************************************************************
     * Cell2D utility functions
     *****************************************************************************/

    double euclideanDistance( const Cell2D c1, const Cell2D c2 );

    int manhattanDistance( const Cell2D c1, const Cell2D c2 );

    bool isAdjacentN( const Cell2D c1, const Cell2D c2, unsigned int N );

    bool isNull( const Cell2D c );

    /*
    index for adjacentCell and diagonalCell

      0    0    1

     3    [c]    1

      3    2    2

    index for surroundCell

      7    0    4

     3    [c]    1

      6    2    5
    */

    Cell2D adjacentCell( const Cell2D & cell, const int i );

    Cell2D diagonalCell( const Cell2D & cell, const int i );

    Cell2D surroundCell( const Cell2D & cell, const int i );
    
    std::ostream& operator<<( std::ostream &s, const  Cell2D &obj );

    /*****************************************************************************
     * Cell2D inline member functions
     *****************************************************************************/

    inline Cell2D::Cell2D( int x, int y )
    { x_ = x; y_ = y; }

    inline int Cell2D::Cell2D::x() const
    { return x_; }

    inline int Cell2D::Cell2D::y() const
    { return y_; }

    inline void Cell2D::setX( const int x )
    { x_ = x; }

    inline void Cell2D::setY( const int y )
    { y_ = y; }

    inline void Cell2D::set( const int x, const int y )
    { x_ = x; y_ = y; }

    /*****************************************************************************
     * Cell2D arithmetic operator
     *****************************************************************************/

    //members
    inline Cell2D & Cell2D::operator= ( const Cell2D & p )
    { x_=p.x_; y_=p.y_; return *this; }
    
    inline Cell2D & Cell2D::operator+= ( const Cell2D &p )
    { x_+=p.x_; y_+=p.y_; return *this; }

    inline Cell2D & Cell2D::operator-= ( const Cell2D &p )
    { x_-=p.x_; y_-=p.y_; return *this; }

    inline Cell2D & Cell2D::operator*= ( int c )
    { x_*=c; y_*=c; return *this; }

    inline Cell2D & Cell2D::operator/= (int c)
    { if(c==0) return *this; x_/=c; y_/=c; return *this; }

    //friends
    inline bool operator==( const Cell2D &p1, const Cell2D &p2 )
    { return p1.x_ == p2.x_ && p1.y_ == p2.y_; }

    inline bool operator!=( const Cell2D &p1, const Cell2D &p2 )
    { return p1.x_ != p2.x_ || p1.y_ != p2.y_; }

    inline const Cell2D operator+( const Cell2D &p1, const Cell2D &p2 )
    { return Cell2D(p1.x_+p2.x_, p1.y_+p2.y_); }

    inline const Cell2D operator-( const Cell2D &p1, const Cell2D &p2 )
    { return Cell2D(p1.x_-p2.x_, p1.y_-p2.y_); }

    inline const Cell2D operator*( const Cell2D &p, int c )
    { return Cell2D(p.x_*c, p.y_*c); }

    inline const Cell2D operator*( int c, const Cell2D &p )
    { return Cell2D(p.x_*c, p.y_*c); }

    inline const Cell2D operator-( const Cell2D &p )
    { return Cell2D(-p.x_, -p.y_); }
}

#endif