Shapes.h

#ifndef SHAPES_H

#define SHAPES_H

#include <stdexcept>

#include <valarray>

#include <algorithm>

////////////////////////////////////////////////////////////////////////////////

template< typename T >

static double bounded(T value, T minValue, T maxValue)

{

return std::min(std::max(value, minValue), maxValue);

}

template< typename T >

static double bounded(T value, T maxValue = 0.)

{

return bounded(value, 0., maxValue);

}

////////////////////////////////////////////////////////////////////////////////

struct ColorChannel

{

static const double maxValue = 1.;

ColorChannel(double value = 0);

operator double() const;

ColorChannel& operator = (double value);

//...

private:

double value;

};

struct Color

{

ColorChannel red, green, blue, alpha;

Color(ColorChannel red, ColorChannel green, ColorChannel blue,

ColorChannel alpha = 1.);

static const Color blackColor;

static const Color whiteColor;

static const Color grayColor;

};

struct DrawStyle

{

Color lineColor, fillColor;

DrawStyle(Color lineColor = Color::blackColor,

Color fillColor = Color::grayColor);

};

////////////////////////////////////////////////////////////////////////////////

template< typename T, size_t D >

struct Vector

{

Vector (const T& value = 0);

Vector< T, D >& operator += (const Vector< T, D >& value);

Vector< T, D >& operator -= (const Vector< T, D >& value);

Vector< T, D >& operator *= (const T& value);

//...

const T& operator [] (size_t dimension) const throw (std::out_of_range);

T& operator [] (size_t dimension) throw (std::out_of_range);

Vector< T, D >& makePositive();

private:

std::valarray< T > data;

};

template< typename T, size_t D >

Vector< T, D > operator + (const Vector< T, D >& left, const Vector< T, D >& right);

template< typename T, size_t D >

Vector< T, D > operator - (const Vector< T, D >& left, const Vector< T, D >& right);

template< typename T, size_t D >

Vector< T, D > operator * (const Vector< T, D >& left, const T& value);

////////////////////////////////////////////////////////////////////////////////

template< typename T, size_t D >

Vector< T, D >::Vector (const T& value)

: data(value, D)

{}

template< typename T, size_t D >

Vector< T, D >& Vector< T, D >::makePositive()

{

data = abs(data);

return *this;

}

template< typename T, size_t D >

Vector< T, D >& Vector< T, D >::operator += (const Vector< T, D >& value)

{

data += value.data;

return *this;

}

template< typename T, size_t D >

Vector< T, D >& Vector< T, D >::operator -= (const Vector< T, D >& value)

{

data -= value.data;

return *this;

}

template< typename T, size_t D >

Vector< T, D >& Vector< T, D >::operator *= (const T& value)

{

data *= value;

return *this;

}

template< typename T, size_t D >

T& Vector< T, D >::operator [] (size_t dimension) throw (std::out_of_range)

{

if (dimension > D - 1) throw std::out_of_range("dimension error");

return data[dimension];

}

template< typename T, size_t D >

const T& Vector< T, D >::operator [] (size_t dimension) const throw (std::out_of_range)

{

return data[dimension];

}

template< typename T, size_t D >

Vector< T, D > operator + (const Vector< T, D >& left, const Vector< T, D >& right)

{

Vector< T, D > res(left);

res += right;

return res;

}

template< typename T, size_t D >

Vector< T, D > operator - (const Vector< T, D >& left, const Vector< T, D >& right)

{

Vector< T, D > res(left);

res -= right;

return res;

}

template< typename T, size_t D >

Vector< T, D > operator * (const Vector< T, D >& left, const T& right)

{

Vector< T, D > res(left);

res *= right;

return res;

}

typedef double Coord;

typedef Vector< Coord, 2 > Vector2D;

#define X 0

#define Y 1

////////////////////////////////////////////////////////////////////////////////

class Figure

{

public:

virtual ~ Figure ();

virtual DrawStyle& getStyle ();

virtual const DrawStyle& getStyle () const;

protected:

DrawStyle style;

};

template < typename T >

class Shape: public Figure

{

public:

virtual T getCenter () const { return center; }

virtual T getSize () const { return size; }

virtual void setBounds (const T& p1, const T& p2) = 0;

virtual void move (const T& destination) = 0;

virtual bool belongs (const T& point) = 0;

protected:

T center;

T size;

};

typedef Shape< Vector2D > Shape2D;

class Rectangle: public Shape2D

{

public:

Rectangle(const Vector2D& p1, const Vector2D& p2);

virtual void setBounds (const Vector2D& p1, const Vector2D& p2);

virtual void move (const Vector2D& destination);

virtual bool belongs (const Vector2D& point);

};

#endif