// BlurMatrix.cpp: implementation of the CBlurMatrix class.

//

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

#ifdef _WIN32

#include "Windows.h"

#else

#ifdef __sgi

#include <time.h></time.h>

typedef struct timespec {

	time_t tv_sec; /* seconds */

	long tv_nsec;  /* and nanoseconds */

} timespec_t;

int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);

#endif

#endif

#include <vector></vector>

#include <math.h></math.h>

#include <stdlib.h></stdlib.h>

//#include "SError.h"

#include "BlurMatrix.h"

//#include "tmsg.h"

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

// Construction/Destruction

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

using namespace std;

CBlurMatrix::CBlurMatrix(const CBlurMatrix &m) : // throw(SBlurMatrixError) :

												 m_isSAC(m.m_isSAC),

												 m_isRS(m.m_isRS)

{

	try {

		for (int i = 0; i < NBRS; i++)

			m_m[i] = m.m_m[i];

	} catch (exception) {

		throw SBlurMatrixError();

	}

}

CBlurMatrix::CBlurMatrix(const double d, const int nb,

						 const bool isSAC, const bool isRS)

// throw(SBlurMatrixError)

{

	try {

		m_isRS = isRS;

		m_isSAC = isSAC;

		for (int i = 0; i < NBRS; i++)

			m_m[i].clear();

		if (m_isRS) {

			createRandom(d, nb);

		} else

			createEqual(d, nb);

		if (m_isSAC)

			addPath();

	} catch (SBlurMatrixError) {

		throw;

	}

}

bool CBlurMatrix::isIn(const vector<blursection> &m, const SXYD &xyd) const</blursection>

{

	for (vector<blursection>::const_iterator p = m.begin(); p != m.end(); ++p) {</blursection>

		vector<sxyd>::const_iterator pp = p->begin();</sxyd>

		if (pp->x == xyd.x && pp->y == xyd.y)

			return true;

	}

	return false;

}

void CBlurMatrix::createRandom(const double d, const int nb)

//   throw(SBlurMatrixError)

{

	int iNb = 0;

	int l = I_ROUNDP(ceil(d));

	int ll = 2 * l + 1;

	double d2 = d * d;

	//	int maxNb=(int)(4.0*d*d*PI/5.0);

	int maxNb = (int)((double)(d * d) * 2.8) + 1;

	try {

		int i = 0;

		for (i = 0; i < NBRS; i++) {

			BLURSECTION bs;

			SXYD xyd = {0, 0, 0.0};

			bs.push_back(xyd);

			m_m[i].push_back(bs);

			iNb++;

		}

		if (nb <= 0 || d <= 0.01)

			return;

		for (i = 0; i < NBRS; i++) {

			iNb = 1;

			while (iNb < nb && iNb <= maxNb) {

				int x = (rand() % (ll + 1)) - l;

				int y = (rand() % (ll + 1)) - l;

				if (((double)(x * x + y * y) <= d2) && (x != 0 || y != 0)) {

					SXYD xyd1 = {x, y, 0.0};

					if (!isIn(m_m[i], xyd1)) {

						BLURSECTION bs;

						SXYD xyd = {x, y, sqrt((double)(x * x + y * y))};

						bs.push_back(xyd);

						m_m[i].push_back(bs);

						iNb++;

					}

				}

			}

		}

	} catch (exception) {

		throw SBlurMatrixError();

	}

}

void CBlurMatrix::createEqual(const double d, const int nb)

// throw(SBlurMatrixError)

{

	int nq = 0;

	try {

		{

			BLURSECTION bs;

			SXYD xyd = {0, 0, 0.0};

			bs.push_back(xyd);

			m_m[0].push_back(bs);

		}

		if (nb <= 0 || d < 1.0)

			return;

		double b = (double)nb * (2.0 * d + 1.0) * (2.0 * d + 1.0) / (d * d * PI);

		b = sqrt(b);

		b = ceil(b);

		b = (2.0 * d + 1.0) / b;

		int di = (int)ceil(d);

		double d2 = d * d;

		double yd = 0.0;

		for (int y = 0; y <= di;) {

			double xd = 0.0;

			for (int x = 0; x <= di;) {

				double dist = sqrt((double)(x * x + y * y));

				if (dist <= d) {

					{

						BLURSECTION bs;

						SXYD xyd = {x, y, dist};

						bs.push_back(xyd);

						m_m[0].push_back(bs);

						nq++;

					}

					if (x > 0 && y > 0) {

						BLURSECTION bs;

						SXYD xyd = {-x, -y, dist};

						bs.push_back(xyd);

						m_m[0].push_back(bs);

						nq++;

					}

					if (x > 0 && y >= 0) {

						BLURSECTION bs;

						SXYD xyd = {-x, y, dist};

						bs.push_back(xyd);

						m_m[0].push_back(bs);

						nq++;

					}

					if (x >= 0 && y > 0) {

						BLURSECTION bs;

						SXYD xyd = {x, -y, dist};

						bs.push_back(xyd);

						m_m[0].push_back(bs);

						nq++;

					}

				}

				xd += b;

				x = I_ROUND(xd);

			}

			yd += b;

			y = I_ROUND(yd);

		}

	} catch (exception) {

		throw SBlurMatrixError();

	}

}

void CBlurMatrix::addPath(vector<blursection>::iterator pBS)</blursection>

//throw(exception)

{

	try {

		if (pBS->size() > 0) {

			BLURSECTION::iterator xyd = pBS->begin();

			//SXYD* xyd= pBS->begin();

			int x = xyd->x;

			int y = xyd->y;

			int l = max(abs(x), abs(y));

			double dx = -(double)x / (double)l;

			double dy = -(double)y / (double)l;

			double xx = (double)x + dx;

			double yy = (double)y + dy;

			for (int i = 1; i <= l; i++, xx += dx, yy += dy) {

				SXYD xyd1 = {I_ROUND(xx), I_ROUND(yy), 0.0};

				pBS->push_back(xyd1);

			}

		}

	} catch (exception) {

		throw;

	}

}

void CBlurMatrix::addPath() //throw(SBlurMatrixError)

{

	try {

		for (int i = 0; i < (m_isRS ? NBRS : 1); i++) {

			for (vector<blursection>::iterator pBS = m_m[i].begin();</blursection>

				 pBS != m_m[i].end();

				 ++pBS) {

				addPath(pBS);

			}

		}

	} catch (exception) {

		throw SBlurMatrixError();

	}

}

CBlurMatrix::~CBlurMatrix()

{

}

void CBlurMatrix::print() const

{

	/*

	char s[1000];

	OutputDebugString("  ====== Blur Matrix ======\n");

	int nb=m_m[0].size();

	for( int i=0; i

			 int j=0;

			 for( vector<sxyd>::const_iterator pp=m_m[0][i].begin();</sxyd>

				  pp!=m_m[0][i].end();

				  ++pp,++j ) {

				sprintf(s,"(%d,%d,%d,%d) ",i,j,pp->x,pp->y);

				OutputDebugString(s);

			}

			OutputDebugString("\n");

	}

	OutputDebugString("  ========================\n");

*/

}