#include "SCENE.h"

#define TEST_ZONE		50
#define PERCENT_TO_CUT	30

#define BLUR_RADIUS		4
#define BLUR_DERIVE		1
#define ECART_CONTRAST	3

#define GET_R(color) ((int)((color & 0xFF0000) >> 16))
#define GET_G(color) ((int)((color & 0x00FF00) >> 8))
#define GET_B(color) ((int)(color & 0x0000FF))

#define GET_C(color, pos) ( (pos == 0) ? ((int)((color & 0xFF0000) >> 16)) : ((pos == 1) ? ((int)((color & 0x00FF00) >> 8)) : ((int)(color & 0x0000FF))))

/***************************************/
/****** IMAGE CONVERSION FUNCTION ******/
/***************************************/

int CENTER_MAP(MAP *srcMap)
{
	long long	mid;
	int			counterXY;
	int			result;
	s32			*pBASE = srcMap->GetBase();

	mid = 0;
	for (counterXY=0; counterXY < srcMap->SY*srcMap->PITCH; counterXY++)
	{
		mid += pBASE[counterXY];
	}
	mid /= srcMap->SY*srcMap->PITCH;
	
	for (int counterXY=0; counterXY < srcMap->SY*srcMap->PITCH; counterXY++)
	{
		pBASE[counterXY] = (pBASE[counterXY] - mid);
	}
	return mid;
}



void NORMALIZE_MAP(MAP *srcMap, BOOL advance = true);
void NORMALIZE_MAP(MAP *srcMap, BOOL advance)
{
	long long	mid;
	double		ecart;
	double		ecartDouble;
	int			counterXY;
	int			result;
	s32			*pBASE = srcMap->GetBase();

	mid = 0;
	for (counterXY=0; counterXY < srcMap->SY*srcMap->PITCH; counterXY++)
	{
		mid += pBASE[counterXY];
	}
	mid /= srcMap->SY*srcMap->PITCH;
	
	if (advance)
	{
		ecart = 0.0; 
		for (int counterXY=0; counterXY < srcMap->SY*srcMap->PITCH; counterXY++)
		{
			ecart += (pBASE[counterXY] - mid)*(pBASE[counterXY] - mid);
		}
		ecartDouble = (double)ecart/(srcMap->SY*srcMap->PITCH);
		ecart = (int)sqrt(ecartDouble);

		if (ecart == 0)
			return;

		for (int counterXY=0; counterXY < srcMap->SY*srcMap->PITCH; counterXY++)
		{
			result = 512 + (pBASE[counterXY] - mid)*512/(ECART_CONTRAST*ecart);
			if (result >= 1024) result = 1023;
			if (result <  0)	result = 0;
			pBASE[counterXY] = result;
		}
	} else 
	{
		for (int counterXY=0; counterXY < srcMap->SY*srcMap->PITCH; counterXY++)
		{
			result = 512 + (pBASE[counterXY] - mid);
			if (result >= 1024) result = 1023;
			if (result <  0)	result = 0;
			pBASE[counterXY] = result;
		}
	}
}

void NORMALIZE_ZONE(MAP *srcMap, int X, int Y, int SX, int SY, BOOL advance)
{
	long long	mid;
	double		ecart;
	double		ecartDouble;
	int			counterX, counterY;
	int			result;
	s32			*pBASE = srcMap->GetBase();

	mid = 0;
	for (counterY=Y; counterY < Y+SY; counterY++)
	{
		for (counterX=X; counterX < X+SX; counterX++)
		{
			mid += pBASE[counterX + counterY*srcMap->PITCH];
		}
	}
	mid /= SX*SY;
	
	if (advance)
	{
		ecart = 0.0; 
		for (counterY=Y; counterY < Y+SY; counterY++)
		{
			for (counterX=X; counterX < X+SX; counterX++)
			{
				ecart += (pBASE[counterX + counterY*srcMap->PITCH] - mid)*(pBASE[counterX + counterY*srcMap->PITCH] - mid);
			}
		}
		ecartDouble = (double)ecart/(SX*SY);
		ecart = (int)sqrt(ecartDouble);

		if (ecart == 0)
			return;

		for (counterY=Y; counterY < Y+SY; counterY++)
		{
			for (counterX=X; counterX < X+SX; counterX++)
			{
				result = 512 + (pBASE[counterX + counterY*srcMap->PITCH] - mid)*512/(ECART_CONTRAST*ecart);
				if (result >= 1024) result = 1023;
				if (result <  0)	result = 0;
				pBASE[counterX + counterY*srcMap->PITCH] = result;
			}
		}
	} else 
	{
		for (counterY=Y; counterY < Y+SY; counterY++)
		{
			for (counterX=X; counterX < X+SX; counterX++)
			{
				result = 512 + (pBASE[counterX + counterY*srcMap->PITCH] - mid);
				if (result >= 1024) result = 1023;
				if (result <  0)	result = 0;
				pBASE[counterX + counterY*srcMap->PITCH] = result;
			}
		}
	}
}

void
HIGH_FREQUENCIES(MAP *srcMap, MAP *bufferMap, MAP *bufferMap2)
{
	int result;
	s32	*pSrcBASE = srcMap->GetBase();
	s32 *pBufBASE = bufferMap->GetBase();

	LF_GaussianFilter(srcMap, bufferMap, bufferMap2, BLUR_RADIUS, BLUR_DERIVE);
	for (int counterXY=0; counterXY < srcMap->SY*srcMap->PITCH; counterXY++)
	{
		result = 512 + pSrcBASE[counterXY] - pBufBASE[counterXY];
		if (result > 1023)	result = 1023;
		if (result < 0)		result = 0;
		pSrcBASE[counterXY] =	result;
	}
}

void
INVERT_BW(MAP *srcMap, MAP *dstMap)
{
	s32	*pSrcBASE = srcMap->GetBase();
	s32 *pDstBASE = dstMap->GetBase();
	for (int counterXY=0; counterXY < srcMap->SY*srcMap->PITCH; counterXY++)
	{
		pDstBASE[counterXY] = 1023 - pSrcBASE[counterXY];
	}
}


void COPY_II_IN(MAP *MapSRC,MAP *MapDST)
{
	s32 *LAST,*DST,*SRC;
	DST = MapDST->GetBase();
	SRC = MapSRC->GetBase();
	LAST = DST + MapDST->SX;
	while (DST < LAST) 
	{
		*(DST++) = 0;
		*(SRC++) &= 0xfffffffe;
	}
	SRC+=MapSRC->PITCH-MapSRC->SX;
	DST+=MapDST->PITCH-MapDST->SX;

	for (s32 SizeY = 1; SizeY < MapSRC->SY ;SizeY ++)
	{
		LAST = DST + MapDST->SX ;

		*(DST++) = 0;
		*(SRC++) &= 0xfffffffe;
		
		while (DST < LAST) 
		{
			*(DST) =*(SRC);
			*(DST) += *(DST-MapDST->PITCH);
			*(DST) += *(DST-1) - *(DST-1-MapDST->PITCH);
			*(DST++);
			*(SRC++) &= 0xfffffffe;
		}
		SRC+=MapSRC->PITCH-MapSRC->SX;
		DST+=MapDST->PITCH-MapDST->SX;
	}
}







/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/

void MoveRect(RECT *rect, int x, int y)
{
	rect->left += x;
	rect->right += x;
	rect->top += y;
	rect->bottom += y;
}

u32 ABS_DIFF(MAP *patch, MAP *base, POINT offset)
{
	s32 *LAST,*pBASE,*PATCH;
	u32 result = 0;
	int localResult;

	pBASE = base->GetBase() + offset.x + offset.y*base->PITCH;
	PATCH= patch->GetBase();
	
	for (s32 SizeY = 0; SizeY < patch->SY ;SizeY ++)
	{
		LAST = PATCH + patch->SX;
		while (PATCH < LAST) 
		{
			localResult = *(PATCH++) - *(pBASE++);
			if (localResult < 0) localResult = -localResult;
			result += localResult;
		}
		PATCH	+= patch->PITCH-patch->SX;
		pBASE	+= base->PITCH -patch->SX;
	}

	return result;
}

POINT TRACK_PATCH(MAP *patch, MAP *source, POINT origin, SIZE searchWin)
{
	u32		curDiff;
	u32		minDiff;
	POINT	offset;
	POINT	offsetEnd;
	POINT	newOrigin = origin;

	minDiff = -1;

	offsetEnd.x = origin.x + searchWin.cx/2;
	if (offsetEnd.x > source->SX) offsetEnd.x = source->SX;
	offsetEnd.y = origin.y + searchWin.cy/2;
	if (offsetEnd.y > source->SY) offsetEnd.y = source->SY;

	for (offset.y=origin.y-searchWin.cy/2; offset.y < offsetEnd.y; offset.y++)
	{
		if (offset.y < 0) continue;
		for (offset.x=origin.x-searchWin.cx/2; offset.x < offsetEnd.x; offset.x++)
		{
			if (offset.x < 0) continue;
			curDiff = ABS_DIFF(patch, source, offset);
			if (minDiff > curDiff)
			{
				minDiff		= curDiff;
				newOrigin	= offset;
			}
		}
	}
	return newOrigin;
}

void COPY_SUB(MAP *dst, MAP *src, POINT offset)
{
	s32 *LAST,*SRC,*DST;

	SRC	= src->GetBase() + offset.x + offset.y*src->PITCH;
	DST = dst->GetBase();
	
	for (s32 SizeY = 0; SizeY < dst->SY ;SizeY ++)
	{
		memcpy(DST, SRC, dst->SX*sizeof(int));
		SRC	+= src->PITCH;
		DST	+= dst->PITCH;
	}
}








































/*******************************************************************************/
/*******************************************************************************/
/********************************  ADA BOOST ***********************************/
/*******************************************************************************/
/*******************************************************************************/

//// version 1 patch binaire

typedef struct Patch_
{
	char x; 
	char y; 
	char width;
	char height;
	char isWhite;
	char isOpositeLeft;
} Patch;


inline int GetPatchResult(MAP *srcII, Patch *patch)
{
	int z1, z2;
	s32	*pBASE = srcII->GetBase();

	z1 =pBASE[patch->x + patch->width	+ (patch->y + patch->height	)*srcII->PITCH] -
		pBASE[patch->x				+ (patch->y + patch->height	)*srcII->PITCH] -
		pBASE[patch->x + patch->width	+ (patch->y					)*srcII->PITCH] +
		pBASE[patch->x				+ (patch->y					)*srcII->PITCH];
	if (patch->isOpositeLeft)
	{
		z2 =pBASE[patch->x + 2*patch->width	+ (patch->y + patch->height	)*srcII->PITCH] -
			pBASE[patch->x + patch->width		+ (patch->y + patch->height	)*srcII->PITCH] -
			pBASE[patch->x + 2*patch->width	+ (patch->y					)*srcII->PITCH] +
			pBASE[patch->x + patch->width		+ (patch->y					)*srcII->PITCH];
	} else
	{
		z2 =pBASE[patch->x + patch->width	+ (patch->y + 2*patch->height	)*srcII->PITCH] -
			pBASE[patch->x +				+ (patch->y + 2*patch->height	)*srcII->PITCH] -
			pBASE[patch->x + patch->width	+ (patch->y + patch->height		)*srcII->PITCH] +
			pBASE[patch->x +				+ (patch->y + patch->height		)*srcII->PITCH];
	}
	if (patch->isWhite)
		return z1 < z2;
	else
		return z1 > z2;
}


float getPatchGlobalResultErrors(Patch *patch, float *diFactor, MAP **positivIIList, int nbPositiv, MAP **negativIIList, int nbNegativ)
{
	int		counter;
	int		errorCount;
	double	result = 0;

	for (counter = 0; counter < nbPositiv; counter++)
	{
		if (!GetPatchResult(positivIIList[counter], patch))
			result += diFactor[counter];
	}

	for (counter = 0; counter < nbNegativ; counter++)
	{
		if (GetPatchResult(negativIIList[counter], patch))
			result += diFactor[counter+nbPositiv];
	}
	
	return (float)result;
}

void SearchBestPatch(float *diFactor, MAP **positivIIList, int nbPositiv, MAP **negativIIList, int nbNegativ)
{
	int maxWidth;
	int maxHeight;
}