// BlurMatrix.cpp: implementation of the CBlurMatrix class.
//
//////////////////////////////////////////////////////////////////////
#ifdef _WIN32
#include "Windows.h"
#else
#ifdef __sgi

#include <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>
#include <algorithm>

#include <cmath>
#include <cstdlib>

//#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
{
	for (vector<BLURSECTION>::const_iterator p = m.begin(); p != m.end(); ++p) {
		vector<SXYD>::const_iterator pp = p->begin();
		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)
//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 = std::max(std::abs(x), std::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();
				 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<nb; i++ ) {
			 int j=0;
			 for( vector<SXYD>::const_iterator pp=m_m[0][i].begin();
				  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");
*/
}