// PatternPosition.cpp: implementation of the CPatternPosition class.

//

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

#ifdef WIN32

#pragma warning(disable : 4996)

#endif

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

#include <string.h>

#include "PatternPosition.h"

#include "SError.h"

#include "SDef.h"

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

// Construction/Destruction

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

using namespace std;

CPatternPosition::~CPatternPosition()

{

	m_pos.clear();

}

bool CPatternPosition::isInSet(const int nbSet, const int *set, const int val)

{

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

		if (set[i] == val)

			return true;

	return false;

}

int pp_intCompare(const void *a, const void *b)

{

	int *aa = (int *)a;

	int *bb = (int *)b;

	if (*aa < *bb)

		return -1;

	if (*aa > *bb)

		return 1;

	return 0;

}

void CPatternPosition::makeRandomPositions(const int nbPat, const int nbPixel,

										   const int lX, const int lY, const UCHAR *sel)

{

	try {

		const UCHAR *pSel = sel;

		int threshold = RAND_MAX * (double)nbPat / (double)nbPixel;

		for (int y = 0; y < lY; y++)

			for (int x = 0; x < lX; x++, pSel++)

				if (*pSel > (UCHAR)0) {

					if (rand() < threshold) {

						SPOINT xyp = {x, y};

						m_pos.push_back(xyp);

					}

				}

	} catch (exception) {

		char s[50];

		sprintf(s, "in Pattern Position Generation");

		throw SMemAllocError(s);

	}

}

void CPatternPosition::getPosAroundThis(const int lX, const int lY, const UCHAR *lSel,

										const int xx, const int yy,

										int &xPos, int &yPos)

{

	vector<SPOINT> ddc;

	prepareCircle(ddc, 2.0);

	int qx = 0, qy = 0, q = 0;

	for (vector<SPOINT>::iterator p = ddc.begin();

		 p != ddc.end();

		 p++) {

		int x = xx + p->x;

		int y = yy + p->y;

		if (x >= 0 && y >= 0 && x < lX && y < lY)

			if (*(lSel + y * lX + x) > (UCHAR)0) {

				qx += x;

				qy += y;

				q++;

			}

	}

	if (q > 0) {

		double dx = (double)qx / (double)q;

		double dy = (double)qy / (double)q;

		xPos = I_ROUND(dx);

		yPos = I_ROUND(dy);

	} else {

		xPos = xx;

		yPos = yy;

	}

}

bool CPatternPosition::findEmptyPos(const int lX, const int lY, const UCHAR *lSel,

									int &xPos, int &yPos, SRECT &bb)

{

	int y = 0;

	for (y = 0; y <= yPos; y++)

		for (int x = xPos; x <= bb.x1; x++)

			if (*(lSel + y * lX + x) == (UCHAR)1) {

				//				getPosAroundThis(lX,lY,lSel,x,y,xPos,yPos);

				xPos = x;

				yPos = y;

				return true;

			}

	for (y = yPos; y <= bb.y1; y++)

		for (int x = bb.x0; x <= bb.x1; x++)

			if (*(lSel + y * lX + x) == (UCHAR)1) {

				//				getPosAroundThis(lX,lY,lSel,x,y,xPos,yPos);

				xPos = x;

				yPos = y;

				return true;

			}

	return false;

}

void CPatternPosition::eraseCurrentArea(const int lX, const int lY, UCHAR *lSel,

										vector<SPOINT> &ddc, const int xx, const int yy)

{

	for (vector<SPOINT>::iterator pDdc = ddc.begin();

		 pDdc != ddc.end();

		 pDdc++) {

		int x = xx + pDdc->x;

		int y = yy + pDdc->y;

		if (x >= 0 && y >= 0 && x < lX && y < lY) {

			UCHAR *pSel = lSel + y * lX + x;

			if (*(pSel) == (UCHAR)1)

				*(pSel) = (UCHAR)2;

		}

	}

}

void CPatternPosition::sel0255To01(const int lX, const int lY, UCHAR *sel, SRECT &bb)

{

	UCHAR *pSel = sel;

	bb.x0 = lX;

	bb.y0 = lY;

	bb.x1 = -1;

	bb.y1 = -1;

	for (int y = 0; y < lY; y++)

		for (int x = 0; x < lX; x++, pSel++)

			if (*pSel >= (UCHAR)1) {

				*pSel = (UCHAR)1;

				bb.x0 = MIN(x, bb.x0);

				bb.x1 = MAX(x, bb.x1);

				bb.y0 = MIN(y, bb.y0);

				bb.y1 = MAX(y, bb.y1);

			}

}

void CPatternPosition::prepareCircle(vector<SPOINT> &v, const double r)

{

	try {

		double r2 = r * r;

		int rr = (int)r + 1;

		for (int y = -rr; y <= rr; y++)

			for (int x = -rr; x <= rr; x++)

				if ((double)(x * x + y * y) <= r2) {

					SPOINT sp = {x, y};

					v.push_back(sp);

				}

	} catch (exception) {

		char s[50];

		sprintf(s, "Position Generation");

		throw SMemAllocError(s);

	}

}

void CPatternPosition::makeDDPositions(const int lX, const int lY, UCHAR *sel,

									   const double minD, const double maxD)

{

	const int maxNbDDC = 20;

	vector<SPOINT> ddc[maxNbDDC];

	UCHAR *lSel = 0;

	// Checking parameters

	if (lX <= 0 || lY <= 0 || !sel)

		return;

	if (minD > maxD)

		return;

	// Preparing circles

	int nbDDC = fabs(maxD - minD) < 0.001 ? 1 : maxNbDDC;

	try {

		if (nbDDC == 1) {

			prepareCircle(ddc[0], minD);

		} else {

			double dDist = (maxD - minD) / (double)(nbDDC - 1);

			double dist = minD;

			for (int i = 0; i < nbDDC; i++, dist += dDist)

				prepareCircle(ddc[i], dist);

		}

	} catch (SMemAllocError) {

		throw;

	}

	// Preparing local selection

	lSel = new UCHAR[lX * lY];

	if (!lSel) {

		char s[50];

		sprintf(s, "in Pattern Position Generation");

		throw SMemAllocError(s);

	}

	memcpy(lSel, sel, lX * lY * sizeof(UCHAR));

	SRECT bb;

	sel0255To01(lX, lY, lSel, bb);

	if (bb.x0 > bb.x1 || bb.y0 > bb.y1) {

		delete[] lSel;

		return;

	}

	try {

		int x = 0, y = 0;

		while (findEmptyPos(lX, lY, lSel, x, y, bb)) {

			SPOINT sp = {x, y};

			m_pos.push_back(sp);

			int iddc = nbDDC == 1 ? 0 : rand() % nbDDC;

			eraseCurrentArea(lX, lY, lSel, ddc[iddc], sp.x, sp.y);

		}

		delete[] lSel;

	} catch (exception) {

		delete[] lSel;

		char s[50];

		sprintf(s, "in Pattern Position Generation");

		throw SMemAllocError(s);

	}

	//	memcpy(sel,lSel,lX*lY);

}