#ifndef _COMMON_CATMULL_HPP_
#define _COMMON_CATMULL_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_ARRAY_HPP_
#include <common/array.hpp>
#endif

class FloatPairs
{
public:
	FloatPairs(void);
  FloatPairs(const FloatPairs &someFloatPairs);
	FloatPairs(double column,double row);
	virtual ~FloatPairs();
  FloatPairs &operator=(const FloatPairs &someFloatPairs);
	WORD operator==(const FloatPairs &someFloatPair)const;
	double column(void)const;
  void column(double newColumn);
	double row(void)const;
	void row(double newRow);
	void setPairs(double newColumn,double newRow);
	void setPairs(int newColumn,int newRow);
	static int fpmax(int firstVal,int secondVal);
	static int fpmin(int firstVal,int secondVal);
private:
	double mColumn;
	double mRow;
};

inline
FloatPairs::FloatPairs(void)
: mColumn(0.00), mRow(0.00)
{
}

inline
FloatPairs::FloatPairs(const FloatPairs &someFloatPairs)
{
  *this=someFloatPairs;
}

inline
FloatPairs::FloatPairs(double column,double row)
: mColumn(column), mRow(row)
{
}

inline
FloatPairs::~FloatPairs()
{
}

inline
WORD FloatPairs::operator==(const FloatPairs &someFloatPair)const
{
	return (mColumn==someFloatPair.mColumn && mRow==someFloatPair.mRow);
}

inline
FloatPairs &FloatPairs::operator=(const FloatPairs &someFloatPairs)
{
	column(someFloatPairs.column());
	row(someFloatPairs.row());
	return *this;
}

inline
double FloatPairs::column(void)const
{
	return mColumn;
}

inline
void FloatPairs::column(double newColumn)
{
	mColumn=newColumn;
}

inline
double FloatPairs::row(void)const
{
	return mRow;
}

inline
void FloatPairs::row(double newRow)
{
	mRow=newRow;
}

inline
void FloatPairs::setPairs(double newColumn,double newRow)
{
	mColumn=newColumn;
	mRow=newRow;
}

inline
void FloatPairs::setPairs(int newColumn,int newRow)
{
	mColumn=(double)newColumn;
	mRow=(double)newRow;
}

inline
int FloatPairs::fpmax(int firstVal,int secondVal)
{
	return (firstVal>secondVal?firstVal:secondVal);
}

inline
int FloatPairs::fpmin(int firstVal,int secondVal)
{
	return (firstVal<secondVal?firstVal:secondVal);
}

//  Sample usage of the spline generator...
//  CarmullRom splineGen;
//  Array<FloatPairs> srcPairs;
//  Array<FloatPairs> dstPairs;
//  srcPairs[0]=FloatPairs(1.00,25); 
//  srcPairs[1]=FloatPairs(4.00,50); 
//  dstPairs[0]=FloatPairs(1.00,0.00);
//  dstPairs[1]=FloatPairs(2.00,0.00);
//  dstPairs[2]=FloatPairs(3.00,0.00);
//  dstPairs[3]=FloatPairs(4.00,0.00);
//  splineGen.performSpline(srcPairs,dstPairs);
//  ... dstPairs contains interpolation of 25-50 across four points

class CatmullRom
{
public:
	CatmullRom(void);
	virtual ~CatmullRom();
	WORD performSpline(Array<FloatPairs> &sourcePoints,Array<FloatPairs> &destPoints);
private:
	CatmullRom(const CatmullRom &someCatmullRom);
  CatmullRom &operator=(const CatmullRom &someCatmullRom);
};

inline
CatmullRom::CatmullRom(void)
{
}

inline
CatmullRom::CatmullRom(const CatmullRom &someCatmullRom)
{ // no implementation
  *this=someCatmullRom;
}

inline
CatmullRom::~CatmullRom()
{
}

inline
CatmullRom &CatmullRom::operator=(const CatmullRom &/*someCatmullRom*/)
{ // no implementation
  return *this;
}
#endif