285 lines
No EOL
6.7 KiB
C++
285 lines
No EOL
6.7 KiB
C++
#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
|