/* EDGE CONNEXION */
#include "TRACK.h"
//#define SHOW_PREPASS

u32 TTTR		= 4;
u32 __55_RADIUS	= 1;


static s32 Map[512 * 512 * 4];
static s32 Map1[512 * 512 * 4];
static s32 Map2[512 * 512 * 4];
static s32 Map3[512 * 512 * 4];
static s32 Map4[512 * 512 * 4];
static s32 Map5[512 * 512 * 4];

static u32 *LateBuffer = NULL;
static u32 LateBufferPos;
static u32 SaveXY = 0;


static s32 Thresh_Table2[65536];
static s32 LOG_Table2[65536];
static s32 OneOverSquareRoot_Table2[65536];
static u32 XY_2_Color[65536];
static u32 XY_2_MASK[65536];
#define FIFO_SIZE 16


#define VQ

#define BORDER_LIMIT 10
//#define MAX_TRUCS 50
//#define SHOW_RATIO
//
#define SHOW_TESTOUILLE
//#define FLIPV

//#define LATERPLEASE
//#define MIPMAPPING//
//#define EQUALIZE
#define u8 unsigned char
extern void DRawTEXT_Soft_B(u8 *pTEXT,u32 *pBase,u32 X, u32 Y, s32 Pitch , u32 Height , u32 Color);

#define TTT 0.000f
#define GTV 50.0f
#define COLOR_AND 0xffffffff//*/0x70000000


#define __55_RADIUS_RATIO __55_RADIUS
#define __55_RADIUS_BIG	(__55_RADIUS + (__55_RADIUS>>0))//<< impair !!
#define __55_RADIUS_RATIO_BIG (__55_RADIUS_RATIO + (__55_RADIUS_RATIO>>0))//<< impair !!
#define SMALL_SURFACE ((((__55_RADIUS)<<1) + 1) * (((__55_RADIUS)<<1) + 1))
#define BIG_SURFACE  ((((__55_RADIUS_BIG)<<1) + 1) * (((__55_RADIUS_BIG)<<1) + 1))

//#define PIXEL_LENGHT_TRESH ((__55_RADIUS_BIG << 2))

#define PRECISION_BITS  0

u32 HOUGHT_T[256*256];
u32 ASIN_TABLE[65536];


extern u32 BitNum(u32 K);
extern  void BUILD_MIPMAPPING(MAP *MapDST);

#define II_TYPE float

static void COPY_TOFLAT_II(MAP *MapSRC,MAP *MapDST,s32 Noise)
{
	s32 *LAST,*DST,*SRC;
	DST = MapDST->BASE;
	SRC = MapSRC->BASE;
#define Rodios 1

	for (u32 SizeY = 0; SizeY < Rodios;SizeY ++)
	{
		LAST = DST + MapDST->SX;
		while (DST < LAST) 
		{
			*(DST++) = 0;
			*(SRC++);
		}
		SRC+=MapSRC->PITCH-MapSRC->SX;
		DST+=MapDST->PITCH-MapDST->SX;
	}

	for (u32 SizeY = Rodios; SizeY < MapSRC->SY - Rodios;SizeY ++)
	{
		LAST = DST + MapDST->SX;
		
		while (DST < LAST) 
		{
			s32 A;
			A = ((*(SRC) & 0xff0000) + ((*(SRC) & 0xff00)<<9) + ((*(SRC) & 0xff)<<16))>>(16 - PRECISION_BITS);
			*(SRC) = A>>2;
			//A -= Noise;
			*(II_TYPE*)(DST) =(II_TYPE)A;
			*(II_TYPE*)(DST) += *(II_TYPE*)(DST-MapDST->PITCH);
			*(II_TYPE*)(DST) += *(II_TYPE*)(DST-1) - *(II_TYPE*)(DST-1-MapDST->PITCH);
			*(DST++);
			SRC++;
			A = ((*(SRC) & 0xff0000) + ((*(SRC) & 0xff00)<<9) + ((*(SRC) & 0xff)<<16))>>(16 - PRECISION_BITS);
			*(SRC) = A>>2;
			//A += Noise;
			*(II_TYPE*)(DST) =(II_TYPE)A;
			*(II_TYPE*)(DST) += *(II_TYPE*)(DST-MapDST->PITCH);
			*(II_TYPE*)(DST) += *(II_TYPE*)(DST-1) - *(II_TYPE*)(DST-1-MapDST->PITCH);
			*(DST++);
			SRC++;
		}
		*(DST) = 0;
		*(DST+1) = 0;
		*(DST+2) = 0;
		SRC+=MapSRC->PITCH-MapSRC->SX;
		DST+=MapDST->PITCH-MapDST->SX;
		*(DST) = 0;
		SizeY ++;
		LAST = DST + MapDST->SX;

		while (DST < LAST) 
		{
			s32 A;
			A = ((*(SRC) & 0xff0000) + ((*(SRC) & 0xff00)<<9) + ((*(SRC) & 0xff)<<16))>>(16 - PRECISION_BITS);
			*(SRC) = A>>2;
			A += Noise;
			*(II_TYPE*)(DST) =(II_TYPE)A;
			*(II_TYPE*)(DST) += *(II_TYPE*)(DST-MapDST->PITCH);
			*(II_TYPE*)(DST) += *(II_TYPE*)(DST-1) - *(II_TYPE*)(DST-1-MapDST->PITCH);
			*(DST++);
			SRC++;
			A = ((*(SRC) & 0xff0000) + ((*(SRC) & 0xff00)<<9) + ((*(SRC) & 0xff)<<16))>>(16 - PRECISION_BITS);
			*(SRC) = A>>2;
			A -= Noise;

			*(II_TYPE*)(DST) =(II_TYPE)A;
			*(II_TYPE*)(DST) += *(II_TYPE*)(DST-MapDST->PITCH);
			*(II_TYPE*)(DST) += *(II_TYPE*)(DST-1) - *(II_TYPE*)(DST-1-MapDST->PITCH);
			*(DST++);
			SRC++;
		}
		*(DST) = 0;
		*(DST+1) = 0;
		*(DST+2) = 0;
		SRC+=MapSRC->PITCH-MapSRC->SX;
		DST+=MapDST->PITCH-MapDST->SX;
		*(DST) = 0;
	}
	LAST = DST + MapDST->SX;
	while (DST < LAST) *(DST++) = *(DST-MapDST->PITCH);
	*(DST) = *(DST-1);
	*(DST+1) = *(DST-1);
	*(DST+2) = *(DST-1);
}

static void COPY_O2_II(MAP *MapSRC,MAP *MapDST)
{
	II_TYPE *LAST,*DST,*SRC,*SRC2;
	DST = (II_TYPE *)MapDST->BASE;
	SRC = (II_TYPE *)MapSRC->BASE;
	for (s32 SizeY = 0; SizeY < MapDST->SY;SizeY ++)
	{
		LAST = DST + MapDST->SX;
		SRC2 = SRC + MapSRC->PITCH;
		while (DST < LAST)
		{
			*(DST++) = ((*(SRC) + *(SRC + 1)  + *(SRC2)  + *(SRC2 + 1))) / 16.0f; // +2 -> II
			SRC += 2;
			SRC2 += 2;
		}
		*(DST) = *(DST-1);
		SRC+=(MapSRC->PITCH-MapSRC->SX);
		SRC+= MapSRC->PITCH;
		DST+=MapDST->PITCH-MapDST->SX;
	}
	LAST = DST + MapDST->SX;
	while (DST < LAST) 
	{
		*(DST) = *(DST-MapDST->PITCH);
		DST++;
	}
	*(DST) = *(DST-1);
}

static void COPY_O2(MAP *MapSRC,MAP *MapDST)
{
	s32 *LAST,*DST,*SRC,*SRC2;
	DST = MapDST->BASE;
	SRC = MapSRC->BASE;
	for (s32 SizeY = 0; SizeY < MapDST->SY;SizeY ++)
	{
		LAST = DST + MapDST->SX;
		SRC2 = SRC + MapSRC->PITCH;
		while (DST < LAST)
		{
			*(DST++) = (*(SRC) + *(SRC + 1)  + *(SRC2)  + *(SRC2 + 1))>>(2); // +2 -> II
			SRC += 2;
			SRC2 += 2;
		}
		SRC+=(MapSRC->PITCH-MapSRC->SX);
		SRC+= MapSRC->PITCH;
		DST+=MapDST->PITCH-MapDST->SX;
	}
}


static void DrawLine(MAP *MapDST,s32 X1,s32 Y1,s32 X2,s32 Y2,u32 Color)
{
	s32 DX,DY,ADY,Inc,Inc2,Counter;
	u32 IThresh,ITCurrent,ITAdd;
	s32 *B0,Pitch;

	if (X1 < 0) X1 = 0;
	if (Y1 < 0) Y1 = 0;
	if (X1 > (s32)MapDST->SX) X1 = MapDST->SX;
	if (Y1 > (s32)MapDST->SY) Y1 = MapDST->SY;

	if (X2 < 0) X2 = 0;
	if (Y2 < 0) Y2 = 0;
	if (X2 > (s32)MapDST->SX) X2 = MapDST->SX;
	if (Y2 > (s32)MapDST->SY) Y2 = MapDST->SY;

	*(MapDST->BASE + X1 + Y1 * MapDST->PITCH) = Color;
	*(MapDST->BASE + X2 + Y2 * MapDST->PITCH) = Color;

	if (X2 < X1)
	{
		/* Swap */
		DX = X1; X1 = X2; X2 = DX;
		DY = Y1; Y1 = Y2; Y2 = DY;
	}

	B0 = MapDST->BASE;	Pitch = MapDST->PITCH;	B0 += Y1 * Pitch + X1;

	DX = X2 - X1;	DY = Y2 - Y1;
	if (DX == 0)
	{
		if (DY < 0) {DY = -DY;while (DY--) *(B0 - DY * Pitch) = Color;		} 
			else {			  while (DY--) *(B0 + DY * Pitch) = Color;		}		return;
	}
	if (DY == 0)	{		while (DX--) *B0++ = Color; return;	}
	ADY = abs(DY);
	Inc2 = DY > 0 ? Pitch : -Pitch;	
	if (ADY > DX)	{Inc = Inc2;Inc2 = 1;IThresh = ADY;ITAdd = DX;}
	else			{Inc = 1;IThresh = DX;ITAdd = ADY;	};
	ITCurrent = 0;
	if (ADY > DX)
		Counter = ADY;
	else Counter = DX;
	while (Counter--)
	{
		*B0 = Color;
		ITCurrent += ITAdd;
		if (IThresh <= ITCurrent) 
		{
			B0 += Inc2;
		//	*B0 = Color;
			ITCurrent -= IThresh;
		}
		B0 += Inc;
	}

}
static void DrawLine_ADD_Cond(s32 *DST,s32 Ang,s32 AddV)
{
	s32 D;
	if ((*DST & 0xff)>Ang)
		D = (*DST & 0xff)-Ang;
	else
		D = Ang-(*DST & 0xff);
	if (D & 0x80) D ^= 0xff;
	if (D<30)//*/
	*DST += AddV;
}
static void DrawLine_ADD(MAP *MapDST,s32 X1,s32 Y1,s32 X2,s32 Y2,u32 Color,s32 Ang)
{
	s32 DX,DY,ADY,Inc,Inc2,Counter;
	u32 IThresh,ITCurrent,ITAdd;
	s32 *B0,Pitch;
	if (!Color) return;
	Color<<= 8;


	if (X1 < 0) X1 = 0;
	if (Y1 < 0) Y1 = 0;
	if (X1 > (s32)MapDST->SX) X1 = MapDST->SX;
	if (Y1 > (s32)MapDST->SY) Y1 = MapDST->SY;

	if (X2 < 0) X2 = 0;
	if (Y2 < 0) Y2 = 0;
	if (X2 > (s32)MapDST->SX) X2 = MapDST->SX;
	if (Y2 > (s32)MapDST->SY) Y2 = MapDST->SY;

	if (X2 < X1)
	{
		/* Swap */
		DX = X1; X1 = X2; X2 = DX;
		DY = Y1; Y1 = Y2; Y2 = DY;
	}

	B0 = MapDST->BASE;	Pitch = MapDST->PITCH;	B0 += Y1 * Pitch + X1;

	DX = X2 - X1;	DY = Y2 - Y1;
	if (DX == 0)
	{
		if (DY < 0) {DY = -DY;while (DY--) 	DrawLine_ADD_Cond((B0 - DY * Pitch) ,Ang, Color);} 
			else {			  while (DY--)  DrawLine_ADD_Cond((B0 + DY * Pitch) ,Ang, Color);}		return;
	}
	if (DY == 0)	{		while (DX--) DrawLine_ADD_Cond((B0++) ,Ang, Color); return;	}
	ADY = abs(DY);
	Inc2 = DY > 0 ? Pitch : -Pitch;	
	if (ADY > DX)	{Inc = Inc2;Inc2 = 1;IThresh = ADY;ITAdd = DX;}
	else			{Inc = 1;IThresh = DX;ITAdd = ADY;	};
	ITCurrent = 0;
	if (ADY > DX)
		Counter = ADY;
	else Counter = DX;
	while (Counter--)
	{
		DrawLine_ADD_Cond(B0 , Ang,Color);
		ITCurrent += ITAdd;
		if (IThresh <= ITCurrent) 
		{
			B0 += Inc2;
		//	*B0 = Color;
			ITCurrent -= IThresh;
		}
		B0 += Inc;
	}

}


static void COPY_TESTOUILLE2(MAP *MapSRC,MAP *MapDST)
{
	s32 *LAST,*DST,*SRC;
	DST = MapDST->BASE;
	SRC = MapSRC->BASE;
	for (u32 SizeY = 0; SizeY < MapSRC->SY;SizeY ++)
	{
		u32 Current;
		LAST = DST + MapSRC->SX;
		Current = 0;
		while (DST < LAST) 
		{
			*(DST)&=0xfcfcfc; 
			*(DST)>>=1;//*/
			//if (*SRC)
			{
			*(DST)=*SRC>>0;
			}
			*(DST++); 
			*(SRC++);
		}
		SRC+=MapSRC->PITCH-MapSRC->SX;
		DST+=MapDST->PITCH-MapSRC->SX;
	}
}


static void COPY(MAP *MapSRC,MAP *MapDST)
{
	s32 *LAST,*DST,*SRC;
	DST = MapDST->BASE;
	SRC = MapSRC->BASE;
	for (u32 SizeY = 0; SizeY < MapSRC->SY;SizeY ++)
	{
		u32 Current;
		LAST = DST + MapSRC->SX;
		Current = 0;
		while (DST < LAST) 
		{
			*(DST++) = *(SRC++);
		}
		SRC+=MapSRC->PITCH-MapSRC->SX;
		DST+=MapDST->PITCH-MapSRC->SX;
	}
}
static u32 Spectrum(u32 Value);
u32 NumberOfLines = 0;
static void AFFECT(MAP *MapSRC,MAP *MapSRC2,MAP *MapDST,MAP *MapDSTR,u32 SHIFT)
{
	s32 *LAST,*DST,*SRC,*SRC2;
	DST = MapDST->BASE;
	SRC = MapSRC->BASE;
	SRC2 = MapSRC2->BASE;
	for (s32 YY = 0; YY < MapSRC->SY;YY ++)
	{
		s32 Current,XX;
		LAST = DST + MapSRC->SX;
		Current = 0;
		XX = 0;
		while (DST < LAST) 
		{
			XX++;
			//*(DST) = Spectrum(*SRC>>8);
//			if ((*DST>>16) & 0xff > 0)
//			{
			if (*DST != 0x00ffffff)
			{
				if (*DST & 0x40000000)
				{
				if (*(SRC)>>0 < 1) *DST = 0&0xff0000;
				else *DST &= 0x40ffffff;
				} else *DST = 0;//*/
//			} else *DST = 0;//*/

			if (*DST&0xffff)
			{
				s32 X1,Y1,DD;

				X1 = (((*(u32*)DST)>>8) & 0xff) - 128;
				Y1 = (((*(u32*)DST)>>0) & 0xff) - 128;

				X1 = abs(X1);
				Y1 = abs(Y1);

				if (X1 < Y1) DD = XX;
				else		 DD = YY;


				//if ((DD & 1)>>SHIFT == 0)
				{
					s32 RX,RY;
					X1 = (((*(u32*)DST)>>8) & 0xff) - 128;
					Y1 = (((*(u32*)DST)>>0) & 0xff) - 128;
					//Y1 = -Y1;
					X1 *= 4;
					Y1 *= 4;
					X1 <<= SHIFT;
					Y1 <<= SHIFT;
					RX = XX << 8+SHIFT;
					RY = YY << 8+SHIFT;
					*(MapDSTR->BASE + (RX>>8) + (RY>>8) * MapDSTR->PITCH) = *DST ;//*/
					//DrawLine(MapDSTR,(RX + X1)>>8,(RY + Y1)>>8,(RX - X1)>>8,(RY - Y1)>>8,0x00ffffff);//*/
					//DrawLine(MapDSTR,(RX + Y1)>>8,(RY - X1)>>8,(RX - Y1)>>8,(RY + X1)>>8,0|*DST);//*/
					//if (SHIFT == 0)
					/*if (SHIFT)
					DrawLine(MapDSTR,(RX + Y1)>>8,(RY - X1)>>8,(RX - Y1)>>8,(RY + X1)>>8,0xff000000>>(SHIFT<<3));//*/
					//if (SHIFT == 0)
						//DrawLine(MapDSTR,(RX + Y1)>>8,(RY - X1)>>8,(RX - Y1)>>8,(RY + X1)>>8,0|*DST);//*/
/*					if (SHIFT)
						DrawLine(MapDSTR,(RX + Y1),(RY - X1),(RX - Y1),(RY + X1),0xff000000>>(SHIFT<<3));//*/
					/*else
					DrawLine(MapDSTR,(RX + Y1)<<SHIFT,(RY - X1)<<SHIFT,(RX - Y1)<<SHIFT,(RY + X1)<<SHIFT,0x00ffffff);//*/
					NumberOfLines++;
				}
			}
			}


			//*(DST) = Spectrum(*SRC>>8);
			*(DST++);
			*(SRC++);
			*(SRC2++);
		}
		SRC+=MapSRC->PITCH-MapSRC->SX;
		SRC2+=MapSRC2->PITCH-MapSRC2->SX;
		DST+=MapDST->PITCH-MapSRC->SX;
	}
}

static void SET(MAP *MapDST,s32 Value)
{
	s32 *LAST,*DST;
	DST = MapDST->BASE;
	for (u32 SizeY = 0; SizeY < MapDST->SY;SizeY ++)
	{
		u32 Current;
		LAST = DST + MapDST->SX;
		Current = 0;
		while (DST < LAST) 
		{
			*(DST++) = Value;
		}
		DST+=MapDST->PITCH-MapDST->SX;
	}
}
static void DARKER(MAP *MapDST)
{
	s32 *LAST,*DST;
	DST = MapDST->BASE;
	for (u32 SizeY = 0; SizeY < MapDST->SY;SizeY ++)
	{
		u32 Current;
		LAST = DST + MapDST->SX;
		Current = 0;
		while (DST < LAST) 
		{
			*(DST++) = (*(DST) & 0xfcfcfcfc)>>1;
		}
		DST+=MapDST->PITCH-MapDST->SX;
	}
}
static void SUB_laplacian55_II(MAP *MapSRC,MAP *MapDST,MAP *MapDSTNeg,MAP *MapDSTW)
{
	s32 *LAST,*DST,*DSTN,*DSTW,*SRC,*USRC,*SRCB,*USRCB;
	u32 p1,p1B;

	DST = MapDST->BASE + MapDST->PITCH;
	DSTN = MapDSTNeg->BASE + MapDSTNeg->PITCH;
	DSTW = MapDSTW->BASE + MapDSTW->PITCH;
	SRC = MapSRC->BASE + MapSRC->PITCH;

	p1 = __55_RADIUS * 2 + 1;
	p1B = __55_RADIUS_BIG * 2 + 1;
	SRC  = MapSRC->BASE + MapSRC->PITCH - (__55_RADIUS + 1) * MapSRC->PITCH - (__55_RADIUS + 1);
	SRCB = MapSRC->BASE + MapSRC->PITCH - (__55_RADIUS_BIG + 1) * MapSRC->PITCH - (__55_RADIUS_BIG + 1);

	for (u32 SizeY = 0; SizeY < __55_RADIUS_BIG;SizeY ++)
	{
		LAST = DST + MapDST->SX;
		while (DST < LAST) {*(DST++) = 0;*(DSTN++) = 0;*(DSTW++) = 0;};
		SRC+=MapSRC->PITCH;
		SRCB+=MapSRC->PITCH;
		DST+=MapDST->PITCH-MapDST->SX;
		DSTN+=MapDSTNeg->PITCH-MapDSTNeg->SX;
		DSTW+=MapDSTW->PITCH-MapDSTW->SX;
	}
	for (u32 SizeY = __55_RADIUS_BIG; SizeY < MapSRC->SY-__55_RADIUS_BIG;SizeY ++)
	{
		II_TYPE SizeX;
		II_TYPE F1,F2,F3;
		register s32 Pitch;

		LAST = DST + MapSRC->SX;

		Pitch = -MapDST->PITCH;
		*(DST-1) = 0;
		*(DSTN-1) = 0;
		*(DSTW-1) = 0;
		USRC = SRC + MapSRC->PITCH * (__55_RADIUS * 2 + 1);
		USRCB = SRCB + MapSRC->PITCH * (__55_RADIUS_BIG * 2 + 1);
		SizeX = 0.0f;
		F1 = F2 = F3 = 0.0f;
		while (DST < LAST) 
		{
			II_TYPE Local,LocalBig;
			Local = *(II_TYPE*)(SRC) - *(II_TYPE*)(SRC+p1) - *(II_TYPE*)(USRC) + *(II_TYPE*)(USRC+p1);
			LocalBig = *(II_TYPE*)(SRCB) - *(II_TYPE*)(SRCB+p1B) - *(II_TYPE*)(USRCB) + *(II_TYPE*)(USRCB+p1B);
			Local *= (float)BIG_SURFACE / (float)SMALL_SURFACE;
			LocalBig -= Local;

			F1 = *(II_TYPE *)(DST) = (II_TYPE)(LocalBig)*SizeX + F1;
			F2 = *(II_TYPE *)(DSTN) = (II_TYPE)(LocalBig)*SizeY + F2;
			F3 = *(II_TYPE *)(DSTW) = (II_TYPE)(LocalBig) + F3;
			*(II_TYPE *)(DST) += *(II_TYPE *)(DST+Pitch);
			*(II_TYPE *)(DSTN) += *(II_TYPE *)(DSTN+Pitch);
			*(II_TYPE *)(DSTW) += *(II_TYPE *)(DSTW+Pitch);

			SizeX++;
			DST++;
			DSTN++;
			DSTW++;
			SRC++;//*/
			USRC++;//*/
			SRCB++;//*/
			USRCB++;//*/
		}
		SRC+=MapSRC->PITCH-MapSRC->SX;
		USRC+=MapSRC->PITCH-MapSRC->SX;
		SRCB+=MapSRC->PITCH-MapSRC->SX;
		USRCB+=MapSRC->PITCH-MapSRC->SX;
		DST+=MapDST->PITCH-MapDST->SX;
		DSTN+=MapDSTNeg->PITCH-MapDSTNeg->SX;
		DSTW+=MapDSTW->PITCH-MapDSTW->SX;
	}
}

static void RATIO55(MAP *MapSRC,MAP *MapSRCN,MAP *MapSRCW,MAP *MapDST,MAP *MapCOLORMAP)
{
	s32 *LAST,*DST,*SRC,*SRCN,*SRCW,*USRC,*USRCN,*USRCW,*SRCCOLOR;
	s32 p1;

	DST = MapDST->BASE + MapDST->PITCH * __55_RADIUS_RATIO_BIG;
	SRCCOLOR = MapCOLORMAP->BASE + MapCOLORMAP->PITCH * __55_RADIUS_RATIO_BIG;
	SRC = MapSRC->BASE + MapSRC->PITCH * __55_RADIUS_RATIO_BIG;
	SRCN = MapSRCN->BASE + MapSRCN->PITCH * __55_RADIUS_RATIO_BIG;
	SRCW = MapSRCW->BASE + MapSRCW->PITCH * __55_RADIUS_RATIO_BIG;

	p1 =  __55_RADIUS_RATIO*2 + 1 ;
	SRC  -= (__55_RADIUS_RATIO + 1) * MapSRC->PITCH  + __55_RADIUS_RATIO + 1;
	SRCN -= (__55_RADIUS_RATIO + 1) * MapSRCN->PITCH + __55_RADIUS_RATIO + 1;
	SRCW -= (__55_RADIUS_RATIO + 1) * MapSRCW->PITCH + __55_RADIUS_RATIO + 1;


	for (u32 SizeY = __55_RADIUS_RATIO_BIG; SizeY < MapSRC->SY-__55_RADIUS_RATIO_BIG;SizeY ++)
	{
		u32 SizeX;
		LAST = DST + MapSRC->SX;
		SizeX = 0;
		USRC  = SRC  + (__55_RADIUS_RATIO*2+1) * MapSRC->PITCH;
		USRCN = SRCN + (__55_RADIUS_RATIO*2+1) * MapSRCN->PITCH;
		USRCW = SRCW + (__55_RADIUS_RATIO*2+1) * MapSRCW->PITCH;
		while (DST < LAST) 
		{
			float Local1,Local2,Local3;
			II_TYPE X,Y,Radius,TTTR_Value,GrdientThresh;
			u32 GLGA;
			GLGA = 0x40;
			*DST = 0;
			X = *(SRCCOLOR - __55_RADIUS_RATIO) - *(SRCCOLOR + __55_RADIUS_RATIO);
			Y = *(SRCCOLOR - MapCOLORMAP->PITCH*__55_RADIUS_RATIO) - *(SRCCOLOR + MapCOLORMAP->PITCH*__55_RADIUS_RATIO);
			GrdientThresh = (X * X + Y * Y);
			if (GrdientThresh > GTV)
			{
				Local3 = *(II_TYPE*)(SRCW) - *(II_TYPE*)(SRCW +p1) - *(II_TYPE*)(USRCW) + *(II_TYPE*)(USRCW+p1);
				if (Local3)
				{

					Local1 = *(II_TYPE*)(SRC ) - *(II_TYPE*)(SRC + p1) - *(II_TYPE*)(USRC ) + *(II_TYPE*)(USRC + p1);
					Local2 = *(II_TYPE*)(SRCN) - *(II_TYPE*)(SRCN +p1) - *(II_TYPE*)(USRCN) + *(II_TYPE*)(USRCN +p1);
					X = ((II_TYPE)SizeX - Local1 / (Local3));
					Y = ((II_TYPE)SizeY - 1 - Local2 / (Local3));

					Radius = (X * X + Y * Y);

					if (Radius >= TTTR)
						*DST|= 0x40000000;//*/
					{
						
						if (Local3<0)
						{
							X = -X;
							Y = -Y;
						}
						Radius = 1.0f / sqrtf(Radius);
						X *= Radius;
						Y *= Radius;

						Local3= 32.0f*(GrdientThresh - GTV) /*/ 3.0f*/;
						if (Local3 < 0) Local3 = -Local3;
						Local3 = sqrtf(Local3);
						if (Local3 > 255) Local3 = 255;

						X *= 100.0f;
						Y *= 100.0f;
						X += 128.0f;
						Y += 128.0f;
						if (X < 0) X = 0;
						if (X > 255) X = 255;
						if (Y < 0) Y = 0;
						if (Y > 255) Y = 255;
						*DST|= ((u32)Local3)<<16;
						*DST|= ((u32)X)<<8;
						*DST|= ((u32)Y)<<0;//*/
							
					} 

				}
			}
			*DST &= ~0x10000000;
			SizeX++;
			DST++;
			SRC++;
			SRCN++;
			SRCW++;
			USRC++;
			USRCN++;
			USRCW++;
			SRCCOLOR++;

		}
		SRC+=MapSRC->PITCH-MapSRC->SX;
		SRCN+=MapSRCN->PITCH-MapSRCN->SX;
		SRCW+=MapSRCW->PITCH-MapSRCW->SX;
		DST+=MapDST->PITCH-MapSRC->SX;
		SRCCOLOR+= MapCOLORMAP->PITCH-MapCOLORMAP->SX;

	}
}

void Compute_HOUGHT_T(MAP *MapDST,MAP *MapDSTResult)
{
	MAP MapDSTSave;
	s32 *LAST,*DST,*SRC;
	MapDSTSave = *MapDST;
	DST = MapDST->BASE;
	for (s32 YY = 0; YY < MapDST->SY;YY ++)
	{
		s32 Current,XX;
		LAST = DST + MapDST->SX;
		Current = 0;
		XX = 0;
		while (DST < LAST)
		{
			float X,Y;
			s32 ANG,DT0;
			if (*DST & 0x40000000)
			{
				s32 X1,Y1,STR;
				s32 Angle,Saved;

				//*DST |= 0xFF000000;
				X1 = (((*(u32*)DST)>>0) & 0xff) - 128;
				Y1 = (((*(u32*)DST)>>8) & 0xff) - 128;
				Y1 = -Y1;

				X1 >>= 3;
				Y1 >>= 3;


				Angle = ASIN_TABLE[*DST & 0xffff];
				STR = ((*((u32*)DST)>>16) & 0xff) + 0;
				STR *= STR;
				STR>>= 8;//*/
/* 				STR *= STR;
				STR>>= 8;//*/
				//STR = 10;
				
				DrawLine_ADD(MapDSTResult,XX + X1,YY + Y1,XX - X1,YY - Y1,STR>>3,Angle);
				X1 >>= 1;
				Y1 >>= 1;
				DrawLine_ADD(MapDSTResult,XX + X1,YY + Y1,XX - X1,YY - Y1,STR>>2,Angle);
				X1 >>= 1;
				Y1 >>= 1;
				DrawLine_ADD(MapDSTResult,XX + X1,YY + Y1,XX - X1,YY - Y1,STR>>1,Angle);
				X1 >>= 1;
				Y1 >>= 1;
				DrawLine_ADD(MapDSTResult,XX + X1,YY + Y1,XX - X1,YY - Y1,STR>>0,Angle);
			}
			DST++;
			XX++;
		}
		DST+=MapDST->PITCH-MapDST->SX;
	}

	*MapDST = MapDSTSave;
}
static void SET_T(MAP *MapDST)
{
	s32 *LAST,*DST;
	DST = MapDST->BASE;
	for (u32 SizeY = 0; SizeY < MapDST->SY;SizeY ++)
	{
		u32 Current;
		LAST = DST + MapDST->SX;
		Current = 0;
		while (DST < LAST) 
		{
			*(DST++) = ASIN_TABLE[*DST & 0xffff] & 0xff;
		}
		DST+=MapDST->PITCH-MapDST->SX;
	}
}


void MC_GC2(s32 *SourceMAp,u32 Pitch,u32 SizeX,u32 SizeY)
{
	static MAP SOURCEMAP;
	static MAP LOG[30];
	static MAP LOG1[30];
	static MAP LOG2[30];
	static MAP LOG3[30];
	static MAP LOG4[30];
	static MAP LOG5[30];
	u32 Time,Counter;
	static u32 Init=1;
	SOURCEMAP.BASE = SourceMAp;
	SOURCEMAP.PITCH = Pitch;
	SOURCEMAP.SX = SizeX;
	SOURCEMAP.SY = SizeY;
		Time = timeGetTime();


	if (Init ) 
	{
		Init = 65536;
		while (Init--)
		{
			float X,Y,Norm,Angle;
			X = ((float)((Init >> 8) & 0xff) - 128.0f) / 128.0f;
			Y = ((float)((Init >> 0) & 0xff) - 128.0f) / 128.0f;
			Norm = (X*X + Y*Y);
			Angle = 0;
			if (Norm)
			{
				Norm = sqrtf(Norm);
				if (X != 0.f)
				{
					Angle = acosf(X / Norm) * 128.0f / 3.1415927f;
					if (Y < 0) Angle = 256.0f - Angle;
				} else
				{
					if (Y > 0)
						Angle = 64;
					else
						Angle = 64+128;
				} 

			}
			ASIN_TABLE[Init] = ((u32) Angle) & 0xff;
		}
		

			
		Init = 0;
	}
	{

		s32 LOGNUM,*CurrentBase;
		SOURCEMAP.BASE = SourceMAp;
		SOURCEMAP.PITCH = Pitch;
		SOURCEMAP.SX = SizeX;
		SOURCEMAP.SY = SizeY;
		/* compute maps */
		LOGNUM = 0;
		while(SizeX && SizeY)
		{
			if (LOGNUM == 0)
				CurrentBase = (s32 *)Map + 512;
			else
				CurrentBase += LOG[LOGNUM - 1].PITCH * (LOG[LOGNUM - 1].SY+32);
			LOG[LOGNUM].PITCH = SizeX + 32;
			LOG[LOGNUM].BASE = CurrentBase + 1 + LOG[LOGNUM].PITCH;
			LOG[LOGNUM].SX = SizeX;
			LOG[LOGNUM].SY = SizeY;
			LOG1[LOGNUM] = LOG[LOGNUM];
			LOG1[LOGNUM].BASE = (s32 *)((u32)CurrentBase - (u32)Map + (u32)Map1);
			LOG2[LOGNUM] = LOG[LOGNUM];
			LOG2[LOGNUM].BASE = (s32 *)((u32)CurrentBase - (u32)Map + (u32)Map2);
			LOG3[LOGNUM] = LOG[LOGNUM];
			LOG3[LOGNUM].BASE = (s32 *)((u32)CurrentBase - (u32)Map + (u32)Map3);
			LOG4[LOGNUM] = LOG[LOGNUM];
			LOG4[LOGNUM].BASE = (s32 *)((u32)CurrentBase - (u32)Map + (u32)Map4);
			LOG5[LOGNUM] = LOG[LOGNUM];
			LOG5[LOGNUM].BASE = (s32 *)((u32)CurrentBase - (u32)Map + (u32)Map5);
			LOGNUM++;
			SizeX >>= 1;
			SizeY >>= 1;
		}
	}

	NumberOfLines = 0;
	COPY(&SOURCEMAP,&LOG4[0]);
	COPY_TOFLAT_II(&LOG4[0],&LOG[0],0);
	COPY(&LOG4[0],&LOG5[0]);
	SET(&SOURCEMAP,0);
	DARKER(&SOURCEMAP);
		Time = timeGetTime();
	for (Counter = 0;Counter < 1;Counter++)
	{
		COPY_O2(&LOG5[Counter],&LOG5[Counter+1]);
		COPY_O2(&LOG4[Counter],&LOG4[Counter+1]);
		COPY_TOFLAT_II(&LOG4[Counter],&LOG[Counter],0);
/*		SET(&LOG1[Counter],0);
		SET(&LOG2[Counter],0);
		SET(&LOG3[Counter],0);*/
		SUB_laplacian55_II(&LOG[Counter],&LOG1[Counter],&LOG2[Counter],&LOG3[Counter]);
		SET(&LOG[Counter],0);
		RATIO55(&LOG1[Counter],&LOG2[Counter],&LOG3[Counter],&LOG[Counter],&LOG5[Counter]);
		COPY_TESTOUILLE2(&LOG[Counter],&LOG5[Counter]);
		SET_T(&LOG[Counter]);
		Compute_HOUGHT_T(&LOG5[Counter],&LOG[Counter]);
		COPY(&LOG5[Counter],&LOG1[Counter]);
		//COPY(&LOG[Counter],&SOURCEMAP);
		AFFECT(&LOG[Counter],&LOG4[Counter],&LOG1[Counter],&SOURCEMAP,Counter);//*/
	}//*/

	u8 TEXT[123];
	sprintf((char*)TEXT,"%d",NumberOfLines);
	DRawTEXT_Soft_B(TEXT,(u32*)SOURCEMAP.BASE,10, 20, SOURCEMAP.PITCH, SOURCEMAP.SY, 0xffffff);


	Time = timeGetTime() - Time;
	Time = (u32)((float)SOURCEMAP.SX * (float)Time * 60.0f / 1000.0f);
	if (Time > SOURCEMAP.SX) Time = SOURCEMAP.SX;
	Counter = 10;
	while (Counter--)
	{
		memset(SOURCEMAP.BASE + Counter * SOURCEMAP.PITCH, 0xff , 4*Time);
	}

}


void DETECT_EDGES(MAP *M, int tttr, int radius)
{
	if (tttr > 0)		TTTR		= tttr;
	if (radius >= 0)	__55_RADIUS	= radius;
	MC_GC2(M->BASE,M->PITCH,M->SX,M->SY);
}