private unsafe void Process48bppImage( ushort* baseSrc, ushort* baseDst, int srcStride, int dstStride,
int startX, int startY, int stopX, int stopY, int pixelSize )
{
// loop and array indexes
int i, j, t, k, ir, jr;
// kernel's radius
int radius = size >> 1;
// color sums
long r, g, b, div;
// kernel size
int kernelSize = size * size;
// number of kernel elements taken into account
int processedKernelSize;
ushort* p;
// for each line
for ( int y = startY; y < stopY; y++ )
{
ushort* src = baseSrc + y * srcStride;
ushort* dst = baseDst + y * dstStride;
// for each pixel
for ( int x = startX; x < stopX; x++, src += pixelSize, dst += pixelSize )
{
r = g = b = div = processedKernelSize = 0;
// for each kernel row
for ( i = 0; i < size; i++ )
{
ir = i - radius;
t = y + ir;
// skip row
if ( t < startY )
continue;
// break
if ( t >= stopY )
break;
// for each kernel column
for ( j = 0; j < size; j++ )
{
jr = j - radius;
t = x + jr;
// skip column
if ( t < startX )
continue;
if ( t < stopX )
{
k = kernel[i, j];
p = &src[ir * srcStride + jr * pixelSize];
div += k;
r += k * p[RGB.R];
g += k * p[RGB.G];
b += k * p[RGB.B];
processedKernelSize++;
}
}
}
// check if all kernel elements were processed
if ( processedKernelSize == kernelSize )
{
// all kernel elements are processed - we are not on the edge
div = divisor;
}
else
{
// we are on edge. do we need to use dynamic divisor or not?
if ( !dynamicDivisorForEdges )
{
// do
div = divisor;
}
}
// check divider
if ( div != 0 )
{
r /= div;
g /= div;
b /= div;
}
r += threshold;
g += threshold;
b += threshold;
dst[RGB.R] = (ushort) ( ( r > 65535 ) ? 65535 : ( ( r < 0 ) ? 0 : r ) );
dst[RGB.G] = (ushort) ( ( g > 65535 ) ? 65535 : ( ( g < 0 ) ? 0 : g ) );
dst[RGB.B] = (ushort) ( ( b > 65535 ) ? 65535 : ( ( b < 0 ) ? 0 : b ) );
// take care of alpha channel
if ( pixelSize == 4 )
dst[RGB.A] = src[RGB.A];
}
}
}