Dimensions.hh

Go to the documentation of this file.

/*  Dimensions

PIRL CVS ID: $Id: Dimensions.hh,v 1.27 2011/02/18 02:29:28 castalia Exp $

Copyright (C) 2010  Arizona Board of Regents on behalf of the
Planetary Image Research Laboratory, Lunar and Planetary Laboratory at
the University of Arizona.

This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License, version 2.1,
as published by the Free Software Foundation.

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.
*/

#ifndef _Dimensions_
#define _Dimensions_

#include    <iosfwd>


namespace PIRL
{
/*==============================================================================
    Types
*/
#ifndef COORDINATE_TYPE
#define COORDINATE_TYPE int
#endif
#ifndef DIMENSIONS_TYPE
#define DIMENSIONS_TYPE unsigned COORDINATE_TYPE
#endif

typedef COORDINATE_TYPE Coordinate_Type;
typedef DIMENSIONS_TYPE Dimensions_Type;


inline Coordinate_Type Round (double number)
    {return (Coordinate_Type)(number > 0 ? (number + 0.5) : (number - 0.5));}

//******************************************************************************
struct Point_2D
{
static const char* const
    ID;


Coordinate_Type
    X;
Coordinate_Type
    Y;

/*==============================================================================
    Constructors:
*/
Point_2D ();

Point_2D (const Coordinate_Type& x,const Coordinate_Type& y);

Point_2D (const Point_2D& point);

/*==============================================================================
    Accessors:
*/
inline Point_2D& position (const Coordinate_Type& x,const Coordinate_Type& y)
    {
    X = x;
    Y = y;
    return *this;
    }

inline Point_2D& position (const Point_2D& point)
    {
    X = point.X;
    Y = point.Y;
    return *this;
    }

inline Point_2D& operator= (const Point_2D& point)
    {
    if (this != &point)
        {
        X = point.X;
        Y = point.Y;
        }
    return *this;
    }

inline Point_2D& x (const Coordinate_Type& x_position)
    {X = x_position; return *this;}

inline Coordinate_Type x () const
    {return X;}

inline Point_2D& y (const Coordinate_Type& y_position)
    {Y = y_position; return *this;}

inline Coordinate_Type y () const
    {return Y;}

inline bool operator== (const Point_2D& point) const
    {return X == point.X && Y == point.Y;}

inline bool operator!= (const Point_2D& point) const
    {return X != point.X || Y != point.Y;}

inline operator bool ()
    {return X != 0 || Y != 0;}

inline bool is_null ()
    {return X == 0 && Y == 0;}

/*==============================================================================
    Manipulators:
*/
inline Point_2D& operator+= (const Point_2D& offset)
    {X += offset.X; Y += offset.Y; return *this;}

inline Point_2D& operator-= (const Point_2D& offset)
    {X -= offset.X; Y -= offset.Y; return *this;}

inline Point_2D& operator*= (double factor)
    {X = Round (X * factor); Y = Round (Y * factor); return *this;}

Point_2D& operator/= (double factor);

};  //  End of Point_2D class.

inline Point_2D operator+ (const Point_2D& point_1, const Point_2D& point_2)
    {return Point_2D (point_1) += point_2;}

inline Point_2D operator- (const Point_2D& point_1, const Point_2D& point_2)
    {return Point_2D (point_1) -= point_2;}

inline Point_2D operator- (const Point_2D& point)
    {return Point_2D (-point.X, -point.Y);}

inline Point_2D operator* (const Point_2D& point, double factor)
    {return Point_2D (point) *= factor;}

inline Point_2D operator* (double factor, const Point_2D& point)
    {return Point_2D (point) *= factor;}

inline Point_2D operator/ (const Point_2D& point, double factor)
    {return Point_2D (point) /= factor;}

std::ostream& operator<< (std::ostream& stream, const Point_2D& point);

//******************************************************************************
struct Size_2D
{
Dimensions_Type
    Width;
Dimensions_Type
    Height;

/*==============================================================================
    Constructors:
*/
Size_2D ();

Size_2D (const Dimensions_Type& width, const Dimensions_Type& height);

Size_2D (const Dimensions_Type& side);

Size_2D (const Size_2D& size);

/*==============================================================================
    Accessors:
*/
inline Size_2D& size
    (const Dimensions_Type& width, const Dimensions_Type& height)
    {
    Width  = width;
    Height = height;
    return *this;
    }

inline Size_2D& size (const Size_2D& size)
    {
    Width  = size.Width;
    Height = size.Height;
    return *this;
    }

inline Size_2D& operator= (const Size_2D& size)
    {
    if (this != &size)
        {
        Width  = size.Width;
        Height = size.Height;
        }
    return *this;
    }

inline Size_2D& width (const Dimensions_Type& width)
    {Width = width; return *this;}

inline Dimensions_Type width () const
    {return Width;}

inline Size_2D& height (const Dimensions_Type& height)
    {Height = height; return *this;}

inline Dimensions_Type height () const
    {return Height;}

inline unsigned long long area () const
    {return (long long)Width * Height;}

inline bool operator== (const Size_2D& size) const
    {return Width == size.Width && Height == size.Height;}

inline bool operator!= (const Size_2D& size) const
    {return Width != size.Width || Height != size.Height;}

inline operator bool ()
    {return Width != 0 || Height != 0;}

inline bool is_empty ()
    {return Width == 0 || Height == 0;}

/*==============================================================================
    Manipulators:
*/
inline Size_2D& operator+= (const Size_2D& size)
    {Width += size.Width; Height += size.Height; return *this;}

Size_2D& operator-= (const Size_2D& size);

Size_2D& operator*= (double factor);

Size_2D& operator/= (double factor);

};  //  End of Size_2D class.

inline Size_2D operator+ (const Size_2D& size_1, const Size_2D& size_2)
    {return Size_2D (size_1) += size_2;}

inline Size_2D operator- (const Size_2D& size_1, const Size_2D& size_2)
    {return Size_2D (size_1) -= size_2;}

inline Size_2D operator* (const Size_2D& size, double factor)
    {return Size_2D (size) *= factor;}

inline Size_2D operator* (double factor, const Size_2D& size)
    {return Size_2D (size) *= factor;}

inline Size_2D operator/ (const Size_2D& size, double factor)
    {return Size_2D (size) /= factor;}

std::ostream& operator<< (std::ostream& stream, const Size_2D& size);

//******************************************************************************
struct Rectangle
:   public Point_2D,
    public Size_2D
{
/*==============================================================================
    Constructors:
*/
Rectangle ();

Rectangle
    (
    const Coordinate_Type   x,
    const Coordinate_Type   y,
    const Dimensions_Type   width = 0,
    const Dimensions_Type   height = 0
    );

Rectangle (const Point_2D& position, const Size_2D& size);

Rectangle (const Size_2D& size);

Rectangle (const Rectangle& rectangle);

/*==============================================================================
    Accessors:
*/
inline Rectangle& position (const Coordinate_Type& x,const Coordinate_Type& y)
    {Point_2D::position (x, y); return *this;}

inline Rectangle& position (const Point_2D& point)
    {Point_2D::position (point); return *this;}

inline Rectangle& operator= (const Point_2D& point)
    {Point_2D::operator= (point); return *this;}

inline Point_2D position () const
    {return Point_2D (X, Y);}

inline operator Point_2D () const
    {return position ();}

inline Rectangle& size
    (const Dimensions_Type& width, const Dimensions_Type& height)
    {Size_2D::size (width, height); return *this;}

inline Rectangle& size (const Size_2D& size)
    {Size_2D::size (size); return *this;}

inline Rectangle& operator= (const Size_2D& size)
    {Size_2D::operator= (size); return *this;}

inline Size_2D size () const
    {return Size_2D (Width, Height);}

inline operator Size_2D () const
    {return size ();}

inline Rectangle& operator= (const Rectangle& rectangle)
    {
    if (this != &rectangle)
        {
        X = rectangle.X;
        Y = rectangle.Y;
        Width  = rectangle.Width;
        Height = rectangle.Height;
        }
    return *this;
    }

inline bool operator== (const Rectangle& rectangle) const
    {return Point_2D::operator== ((const Point_2D)rectangle) &&
             Size_2D::operator== ((const Size_2D)rectangle);}

inline bool operator!= (const Rectangle& rectangle) const
    {return Point_2D::operator!= ((const Point_2D)rectangle) ||
             Size_2D::operator!= ((const Size_2D)rectangle);}

inline operator bool ()
    {return Point_2D::operator bool () || Size_2D::operator bool ();}

/*==============================================================================
    Manipulators:
*/
inline Rectangle& operator+= (const Point_2D& offset)
    {Point_2D::operator+= (offset); return *this;}

inline Rectangle& operator+= (const Size_2D& size)
    {Size_2D::operator+= (size); return *this;}

inline Rectangle& operator+= (const Rectangle& rectangle)
    {
    Point_2D::operator+= (static_cast<Point_2D>(rectangle));
    Size_2D::operator+= (static_cast<Size_2D>(rectangle));
    return *this;
    }

inline Rectangle& operator-= (const Point_2D& offset)
    {Point_2D::operator-= (offset); return *this;}

inline Rectangle& operator-= (const Size_2D& size)
    {Size_2D::operator-= (size); return *this;}

inline Rectangle& operator-= (const Rectangle& rectangle)
    {
    Point_2D::operator-= (static_cast<Point_2D>(rectangle));
    Size_2D::operator-= (static_cast<Size_2D>(rectangle));
    return *this;
    }

inline Rectangle& operator*= (double factor)
    {Size_2D::operator*= (factor); return *this;}

inline Rectangle& operator/= (double factor)
    {Size_2D::operator/= (factor); return *this;}

Rectangle& operator&= (const Rectangle& rectangle);

Rectangle& operator|= (const Rectangle& rectangle);

};  //  End of Rectangle class.

inline Rectangle operator+ (const Rectangle& rectangle, const Point_2D& point)
    {return Rectangle (rectangle) += point;}

inline Rectangle operator+ (const Point_2D& point, const Rectangle& rectangle)
    {return Rectangle (rectangle) += point;}

inline Rectangle operator+
    (const Rectangle& rectangle_1, const Rectangle& rectangle_2)
    {return Rectangle (rectangle_1) += rectangle_2;}

inline Rectangle operator- (const Rectangle& rectangle, const Point_2D& point)
    {return Rectangle (rectangle) -= point;}

inline Rectangle operator-
    (const Rectangle& rectangle_1, const Rectangle& rectangle_2)
    {return Rectangle (rectangle_1) -= rectangle_2;}

inline Rectangle operator- (const Rectangle& rectangle)
    {return Rectangle (-rectangle.X, -rectangle.Y,
        rectangle.Width, rectangle.Height);}

inline Rectangle operator+ (const Rectangle& rectangle, const Size_2D& size)
    {return Rectangle (rectangle) += size;}

inline Rectangle operator+ (const Size_2D& size, const Rectangle& rectangle)
    {return Rectangle (rectangle) += size;}

inline Rectangle operator- (const Rectangle& rectangle, const Size_2D& size)
    {return Rectangle (rectangle) -= size;}

inline Rectangle operator* (const Rectangle& rectangle, double factor)
    {return Rectangle (rectangle) *= factor;}

inline Rectangle operator* (double factor, const Rectangle& rectangle)
    {return Rectangle (rectangle) *= factor;}

inline Rectangle operator/ (const Rectangle& rectangle, double factor)
    {return Rectangle (rectangle) /= factor;}

inline Rectangle operator&
    (const Rectangle& rectangle_1, const Rectangle& rectangle_2)
    {return Rectangle (rectangle_1) &= rectangle_2;}

inline Rectangle& operator|
    (const Rectangle& rectangle_1, const Rectangle& rectangle_2)
    {return Rectangle (rectangle_1) |= rectangle_2;}

std::ostream& operator<< (std::ostream& stream, const Rectangle& rectangle);

//******************************************************************************
struct Cube
:   public Rectangle
{
Dimensions_Type
    Depth;

/*==============================================================================
    Constructors:
*/
Cube ();

Cube
    (
    const Coordinate_Type   x,
    const Coordinate_Type   y,
    const Dimensions_Type   width = 0,
    const Dimensions_Type   height = 0,
    const Dimensions_Type   depth = 0
    );

Cube (const Point_2D& position, const Size_2D& size);

Cube (const Size_2D& size);

Cube (const Rectangle& rectangle);

Cube (const Cube& cube);

/*==============================================================================
    Accessors:
*/
inline Cube& position (const Coordinate_Type& x,const Coordinate_Type& y)
    {Point_2D::position (x, y); return *this;}

inline Cube& position (const Point_2D& point)
    {Point_2D::position (point); return *this;}

inline Cube& operator= (const Point_2D& point)
    {Point_2D::operator= (point); return *this;}

inline Cube& size
    (const Dimensions_Type& width, const Dimensions_Type& height)
    {Size_2D::size (width, height); return *this;}

inline Cube& size (const Size_2D& size)
    {Size_2D::size (size); return *this;}

inline Cube& depth (Dimensions_Type depth)
    {Depth = depth; return *this;}

inline Dimensions_Type depth () const
    {return Depth;}

inline Cube& operator= (const Size_2D& size)
    {Size_2D::operator= (size); return *this;}

inline Cube& dimensions (const Rectangle& rectangle)
    {Rectangle::operator= (rectangle); return *this;}

inline Cube& operator= (const Rectangle& rectangle)
    {Rectangle::operator= (rectangle); return *this;}

inline Cube& operator= (const Cube& cube)
    {
    if (this != &cube)
        {
        X = cube.X;
        Y = cube.Y;
        Width  = cube.Width;
        Height = cube.Height;
        Depth = cube.Depth;
        }
    return *this;
    }

inline unsigned long long volume () const
    {return area () * Depth;}

inline bool operator== (const Cube& cube) const
    {return Depth == cube.Depth &&
        Rectangle::operator== ((const Rectangle)cube);}

inline bool operator!= (const Cube& cube) const
    {return Depth != cube.Depth ||
        Rectangle::operator!= ((const Rectangle)cube);}

inline operator bool ()
    {return Depth != 0 || Rectangle::operator bool ();}

inline bool is_empty ()
    {return Depth == 0 || Size_2D::is_empty ();}

/*==============================================================================
    Manipulators:
*/
Cube& operator+= (int amount);

inline Cube& operator+= (const Cube& cube)
    {
    Rectangle::operator+= (static_cast<Rectangle>(cube));
    operator+= (cube.Depth);
    return *this;
    }

inline Cube& operator-= (int amount)
    {operator+= (-amount); return *this;}

inline Cube& operator-= (const Cube& cube)
    {
    Rectangle::operator-= (static_cast<Rectangle>(cube));
    operator-= (cube.Depth);
    return *this;
    }

inline Cube& operator*= (double factor)
    {
    Rectangle::operator*= (factor);
    Depth = Round (Depth * factor);
    return *this;
    }

Cube& operator/= (double factor);

Cube& operator&= (const Cube& cube);

Cube& operator|= (const Cube& cube);

};  //  End of Cube class.

inline Cube operator+ (const Cube& cube, int amount)
    {return Cube (cube) += amount;}

inline Cube operator- (const Cube& cube, int amount)
    {return Cube (cube) -= amount;}

inline Cube operator+
    (const Cube& cube_1, const Cube& cube_2)
    {return Cube (cube_1) += cube_2;}

inline Cube operator-
    (const Cube& cube_1, const Cube& cube_2)
    {return Cube (cube_1) -= cube_2;}

inline Cube operator* (const Cube& cube, double factor)
    {return Cube (cube) *= factor;}

inline Cube operator* (double factor, const Cube& cube)
    {return Cube (cube) *= factor;}

inline Cube operator/ (const Cube& cube, double factor)
    {return Cube (cube) /= factor;}

inline Cube operator&
    (const Cube& cube_1, const Cube& cube_2)
    {return Cube (cube_1) &= cube_2;}

inline Cube& operator|
    (const Cube& cube_1, const Cube& cube_2)
    {return Cube (cube_1) |= cube_2;}

std::ostream& operator<< (std::ostream& stream, const Cube& cube);


}   //  namespace PIRL
#endif