FVector FGeomPoly::GetWidgetLocation()
{
const FPoly* Poly = GetActualPoly();
FVector Wk(0.f,0.f,0.f);
if ( Poly->Vertices.Num() > 0 )
{
for( int32 VertIndex = 0 ; VertIndex < Poly->Vertices.Num() ; ++VertIndex )
{
Wk += Poly->Vertices[VertIndex];
}
Wk = Wk / Poly->Vertices.Num();
}
return GetParentObject()->GetActualBrush()->ActorToWorld().TransformPosition( Wk );
}
FVector FGeomPoly::GetMidPoint() const
{
FVector Wk(0,0,0);
int32 Count = 0;
for( int32 e = 0 ; e < EdgeIndices.Num() ; ++e )
{
const FGeomEdge* ge = &GetParentObject()->EdgePool[ EdgeIndices[e] ];
Wk += GetParentObject()->VertexPool[ ge->VertexIndices[0] ];
Count++;
Wk += GetParentObject()->VertexPool[ ge->VertexIndices[1] ];
Count++;
}
check( Count );
return Wk / Count;
}
// Implementation of O(1) cross/joint Bilateral filter algorithm from "Qingxiong Yang, Kar-Han Tan, Narendra Ahuja - Real-Time O(1) Bilateral Filtering"
Plane &Bilateral2D_1(Plane &dst, const Plane &src, const Plane &ref, const Bilateral2D_Data &d, int plane)
{
int i, j, upper;
int k;
int height = ref.Height();
int width = ref.Width();
int stride = ref.Width();
int pcount = ref.PixelCount();
double sigmaS = d.sigmaS[plane];
double sigmaR = d.sigmaR[plane];
int PBFICnum = d.PBFICnum[plane];
const LUT<FLType> &GR_LUT = d.GR_LUT[plane];
// Value range of Plane "ref"
DType rLower, rUpper, rRange;
rLower = ref.Floor();
rUpper = ref.Ceil();
rRange = rUpper - rLower;
// Generate quantized PBFICs' parameters
DType * PBFICk = new DType[PBFICnum];
for (k = 0; k < PBFICnum; ++k)
{
PBFICk[k] = static_cast<DType>(static_cast<double>(rRange)*k / (PBFICnum - 1) + rLower + 0.5);
}
// Generate recursive Gaussian filter object
RecursiveGaussian GFilter(sigmaS, true);
// Generate quantized PBFICs
Plane_FL * PBFIC = new Plane_FL[PBFICnum];
Plane_FL Wk(ref, false);
Plane_FL Jk(ref, false);
for (k = 0; k < PBFICnum; ++k)
{
PBFIC[k] = Plane_FL(ref, false);
for (j = 0; j < height; ++j)
{
i = stride * j;
for (upper = i + width; i < upper; ++i)
{
Wk[i] = Gaussian_Distribution2D_Range_LUT_Lookup(GR_LUT, PBFICk[k], ref[i]);
Jk[i] = Wk[i] * src[i];
}
}
GFilter(Wk, Wk);
GFilter(Jk, Jk);
for (j = 0; j < height; ++j)
{
i = stride * j;
for (upper = i + width; i < upper; ++i)
{
PBFIC[k][i] = Wk[i] == 0 ? 0 : Jk[i] / Wk[i];
}
}
}
// Generate filtered result from PBFICs using linear interpolation
for (j = 0; j < height; ++j)
{
i = stride * j;
for (upper = i + width; i < upper; ++i)
{
for (k = 0; k < PBFICnum - 2; ++k)
{
if (ref[i] < PBFICk[k + 1] && ref[i] >= PBFICk[k]) break;
}
dst[i] = dst.Quantize(((PBFICk[k + 1] - ref[i])*PBFIC[k][i] + (ref[i] - PBFICk[k])*PBFIC[k + 1][i]) / (PBFICk[k + 1] - PBFICk[k]));
}
}
// Clear and output
delete[] PBFIC;
delete[] PBFICk;
return dst;
}
