873 lines
No EOL
21 KiB
C
873 lines
No EOL
21 KiB
C
/* EDGE CONNEXION */
|
|
#include "TRACK.h"
|
|
//#define SHOW_PREPASS
|
|
|
|
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 TTTR 20
|
|
#define GTV 50.0f
|
|
#define COLOR_AND 0xffffffff//*/0x70000000
|
|
|
|
#define __55_RADIUS 2
|
|
|
|
#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)>>8 < 100) *DST = 0&0xff0000;
|
|
else *DST &= 0x4000ffff;
|
|
} 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 *= 2;
|
|
Y1 *= 2;
|
|
X1 <<= SHIFT;
|
|
Y1 <<= SHIFT;
|
|
RX = XX << 8+SHIFT;
|
|
RY = YY << 8+SHIFT;
|
|
//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= (GrdientThresh - GTV) / 3.0f;
|
|
if (Local3 < 0) Local3 = -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 >>= 4;
|
|
Y1 >>= 4;
|
|
|
|
|
|
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]);
|
|
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)
|
|
{
|
|
MC_GC2(M->BASE,M->PITCH,M->SX,M->SY);
|
|
} |