#if 0
#include "SCENE.h"
//#pragma optimize("",off)
typedef struct PatchReport_
{
	float AlphaMin;
	float AlphaMax;
	float NoiseMaxAtCenter;
} PatchReport;

u32 FPA_FastHought(s32 *pSrc,s32 *pDst,s32 Pitch,PatchReport *pPR); 

//#ifndef FastPatchReader_H 




#define MAP32 MAP
#define VectorSize 32

#define FPA_TYPE s32
#define FPA_MAPTYPE MAP32

void MAP32_Mul(MAP *MapDST,s32 Mult,s32 Shift);
void MAP16_Mul(MAP16 *MapDST,s32 Mult,s32 Shift);


FPA_TYPE FalseMap[VectorSize*VectorSize];
FPA_TYPE FalseMap2[VectorSize*VectorSize];
FPA_TYPE FalseMap3[VectorSize*VectorSize];

FPA_TYPE FalseMapSQR[VectorSize*VectorSize];
FPA_TYPE FalseMap2SQR[VectorSize*VectorSize];

void FPA_SwapLines(FPA_TYPE *pSrc,FPA_TYPE *pDst)
{
	u32 Lenght = VectorSize;
	while (Lenght--)
	{
		FPA_TYPE Swp;
		Swp = *pSrc;
		*(pSrc++) = *pDst;
		*(pDst++) = Swp;
	}
}
void FPA_RotateLine(FPA_TYPE *pSrc,s32 Rot)
{
	FPA_TYPE CpyL[VectorSize];
	// In place shift 16 bits horizontaly
	memcpy(CpyL,pSrc,VectorSize*sizeof(FPA_TYPE));
	memcpy(pSrc,CpyL+Rot,(VectorSize-Rot)*sizeof(FPA_TYPE));
	memcpy(pSrc+(VectorSize-Rot),CpyL,Rot*sizeof(FPA_TYPE));
}

void FPA_FastHoughQuadran_Inplace(FPA_MAPTYPE *MapDST,u32 Po2)
{
	FPA_TYPE *DST,*DST2,*LAST;
	MAP32_Shift(MapDST,-1);
	s32 Max = (s32)MapDST->SY & ~((1<<Po2)-1);
	
	/* 1 Shift Lines ***************************************************************************/
	s32 VPos = 2<<Po2;
	if (VPos>2)
	{
		DST = MapDST->GetBase();
		for (s32 SizeY = 0; SizeY < MapDST->SY;SizeY++)
		{
			s32 LocalPos = SizeY & (VPos-1);
			LocalPos ^= (VPos-1);
			if (LocalPos > (VPos>>1))
			{
				LocalPos-=VPos>>1;
				FPA_RotateLine(DST,LocalPos);
			}
			DST += MapDST->PITCH;
		}
	}
	/* 2 Swap lines ***************************************************************************	*/
	VPos = 4;
	while (VPos <= 2<<Po2)
	{
		LAST = MapDST->GetBase() + MapDST->PITCH * MapDST->SY;
		DST = MapDST->GetBase();
		DST2 = DST + MapDST->PITCH * ((VPos>>1)-1);
		for (s32 SizeY = 0; SizeY < MapDST->SY;SizeY++)
		{
			s32 LocalPos = SizeY & (VPos-1);
			if ((LocalPos < VPos>>1) && (LocalPos & 1))/* Swap Lines */FPA_SwapLines(DST,DST2);
			DST += MapDST->PITCH;
			DST2 += MapDST->PITCH;
			//if (DST2 >= LAST) SizeY = MapDST->SY;

		}
		VPos <<= 1;
	}

	/* 3 Radon trans *************************************************************************/
	DST = MapDST->GetBase() ;
	for (s32 SizeY = 0; SizeY < Max;SizeY += 2)
	{
		FPA_TYPE A,B,DSTSave0,DSTSave1;
		
		LAST = DST + MapDST->SX -1;
		DST2 = DST + MapDST->PITCH;
		DSTSave0 = *(DST); 
		DSTSave1 = *(DST2); 

		while (DST < LAST) 
		{
			A =  (*(DST2) + *(DST) ) ;
			B = (*(DST2) + *(DST+1) ) ;
			*(DST2++) =  A;
			*(DST++) = B;
		}
		A =  (*(DST2) + *(DST)) ;
		B = (DSTSave0 + *(DST2));
		*(DST2++) =  A;
		*(DST++) = B;

		DST+=MapDST->PITCH-MapDST->SX;
		DST+=MapDST->PITCH;
	}
}


void FPA_HOUGH(FPA_MAPTYPE *pSrc)
{

}
#define DECLARE_MAP(MAP_NAME,MAP_PTR,MAP_PITCH)\
	FPA_MAPTYPE MAP_NAME;\
	MAP_NAME.SX = VectorSize;MAP_NAME.SY = VectorSize;MAP_NAME.SetBase(MAP_PTR);MAP_NAME.PITCH = MAP_PITCH;


u32 FPA_FastHought(FPA_TYPE *pSrc,FPA_TYPE *pDst,s32 Pitch,PatchReport *pPR)
{
	return 0;
	pSrc -= (VectorSize + VectorSize * Pitch)/2;
	pDst -= (VectorSize + VectorSize * Pitch)/2;
	static u32 Init = 0;
	float TheVector[VectorSize*4];
	memset(TheVector,0,sizeof(TheVector));
	DECLARE_MAP(Sopurce,pSrc,Pitch);
	DECLARE_MAP(Local,FalseMap,VectorSize);
	DECLARE_MAP(SaveMap,FalseMap2,VectorSize);
	DECLARE_MAP(Gaussian,FalseMap3,VectorSize);

	if (!Init)
	{
		Init = 1;
		memset(FalseMap3,0,sizeof(FalseMap3));
		for (int X = 0 ; X < VectorSize ; X++)
			for (int Y = 0 ; Y < VectorSize ; Y++)
			{
				float R = (X - (VectorSize/2)) * (X - (VectorSize/2)) + (Y - (VectorSize/2)) * (Y - (VectorSize/2));
				R = sqrt(R);
				if (R > VectorSize / 2)
					R = VectorSize / 2;
				R = (VectorSize / 2 - R) / (VectorSize / 2);
				R = 2 * R * R * R - 3 * R * R + 1;
				//R *= R * R;
				FalseMap3[X + Y * VectorSize] = 256-R * 256;
			}
	}
	MAP32_Copy(&Sopurce,&SaveMap);
	MAP32_Mul(&Gaussian,&SaveMap);
	MAP32_Shift(&SaveMap,-8);

	float TotalAverageSqr = 0;
	float TotalAverage = 0;
	s32 *pSaveBASE = SaveMap.GetBase();
	for (int X = 0 ; X < VectorSize ; X++)
	for (int Y = 0 ; Y < VectorSize ; Y++)
	{
		float PV = (float)pSaveBASE[X + Y * SaveMap.PITCH];
		TotalAverageSqr += PV*PV;
		TotalAverage += PV;
	}
	TotalAverageSqr /= (float)(VectorSize)*(float)(VectorSize);
	TotalAverage /= (float)(VectorSize)*(float)(VectorSize);
	TotalAverage *= TotalAverage;
	TotalAverageSqr -= TotalAverage;
	TotalAverageSqr = sqrt(TotalAverageSqr);
	


	for (int QQcounter = 0 ; QQcounter < 4 ; QQcounter++)
	{
		void MAP32_BLUR_TransposeFAST(MAP *p);

		MAP32_Copy(&SaveMap,&Local);

		if (QQcounter & 2)
		{
			MAP32_BLUR_TransposeFAST(&Local);
		}

		if (QQcounter & 1) MAP32_FLIP_H(&Local);
		for (u32 Counter = 0; 1<<Counter <  Local.SY; Counter++)	FPA_FastHoughQuadran_Inplace(&Local,Counter);
		MAP32_BLUR_ScissorX_Inplace(&Local,(s32)Local.SY/2,1);
		if (QQcounter & 1) {MAP32_FLIP_H(&Local);MAP32_FLIP_V(&Local);};

	
		s32 *pLocalBASE = Local.GetBase();
		for (int Y = 0;Y < VectorSize; Y++ )
		{
			double Summ = 0;	
			double SummSqr = 0;	
			for (int X =0;X < VectorSize; X++ ) 
			{
				Summ += (float)pLocalBASE[X+Y*VectorSize];
				SummSqr += (float)pLocalBASE[X+Y*VectorSize] * (float)pLocalBASE[X+Y*VectorSize];
			}
			SummSqr /= VectorSize;
			Summ /= VectorSize;
			Summ = sqrt(SummSqr-Summ*Summ);
			if (QQcounter & 2)
				TheVector[VectorSize*4 - 1 - (( ( QQcounter& 1) *VectorSize) + Y)] = Summ;
			else
				TheVector[(QQcounter*VectorSize) + Y] = Summ;
		}

		if (QQcounter & 2) MAP32_FLIP_H(&Local);
/*
		Local.SY<<=2;
		LocalSqr.SY<<=2;
*/
		//Local2.GetBase() += Local2.SY * Local2.PITCH;
	}
	/*Local2.SY <<= 1;
	Local2.GetBase() -= Local2.SY * Local2.PITCH;
	MAP32_FLIP_V(&Local2);*/
	float FMin = 100000000.0f;
	u32 IMin = 0;
	float FMax = -100000000.0f;
	u32 IMax = 0;
	float Summ = 0;
	for (int Y = 0;Y < VectorSize*4; Y++ )
	{
		Summ += TheVector[Y];
		if (FMin > TheVector[Y])
		{
			FMin = TheVector[Y];
			IMin = Y;
		}
		if (FMax < TheVector[Y])
		{
			FMax = TheVector[Y];
			IMax = Y;
		}
		//TheVector[Y] *= TheVector[Y];
	}
	Summ /= VectorSize*4;
/*	Summ = (float)VectorSize/sqr0000000000000tf(Summ);
	for (int Y = 0;Y < VectorSize; Y++ )
	{
		TheVector[Y] *= Summ;
		s32 I = TheVector[Y];
		//pDst[I + Y * Pitch] = 0xff0012;
	}*/


	//if (IMin == 5)

	pPR->AlphaMin = (float)IMax / ((float)VectorSize*4.0);
	
	if ((TheVector[IMax] > TotalAverageSqr * 0.6) && 
		//(TheVector[IMax] < 0.25* TheVector_M[IMax]) && 
		(TheVector[IMax] > 50))
	{
		{
			unsigned char TEXT[12];
			sprintf((char*)TEXT,"%d",IMin);
			DRawTEXT_Soft_B(TEXT,(u32*)pDst,0,0,Pitch,16,0xff0012);
		}
		return 1;
	}
	return 0;
}


void FPA_Get2dVector();


#endif