private unsafe static void computeColor(KernelThread thread, byte* frame, int frameStride, Gray<int>[,] orientationImage, Gray<int>[,] magnitudeSqrImage, int minSqrMagnitude)
{
frame = frame + frameStride * thread.Y + thread.X * 3 /*sizeof(Bgr<byte>)*/;
int maxMagSqr = 0, maxDx = 0, maxDy = 0;
for (int ch = 0; ch < 3; ch++)
{
var srcPtr = frame + ch;
int sumX = 0, sumY = 0;
for (int r = 0; r < 3; r++)
{
var chPtr = srcPtr;
for (int c = 0; c < 3; c++)
{
sumX += *chPtr * Sobel_3x3_X[r, c];
sumY += *chPtr * Sobel_3x3_Y[r, c];
chPtr += 3 * sizeof(byte);
}
srcPtr = (byte*)srcPtr + frameStride;
}
//sumX >>= 3; sumY >>= 3; //divide by 8 (normalize kernel)
var grad = sumX * sumX + sumY * sumY;
if (grad > maxMagSqr)
{
maxMagSqr = grad;
maxDx = sumX;
maxDy = sumY;
}
}
if (maxMagSqr < minSqrMagnitude)
{
//magnitudeSqrImage[thread.Y + kernelRadius, thread.X + kernelRadius] = 0; //redundant
orientationImage[thread.Y + kernelRadius, thread.X + kernelRadius] = FeatureMap.INVALID_ORIENTATION;
}
else
{
magnitudeSqrImage[thread.Y + kernelRadius, thread.X + kernelRadius] = maxMagSqr;
orientationImage[thread.Y + kernelRadius, thread.X + kernelRadius] = MathExtensions.Atan2Aprox(maxDy, maxDx);
}
}
private unsafe static void computeGray(KernelThread thread, byte *frame, int frameStride, Gray <int>[,] orientationImage, Gray <int>[,] magnitudeSqrImage, int minSqrMagnitude)
{
frame = frame + frameStride * thread.Y + thread.X;
var srcPtr = frame;
int sumX = 0, sumY = 0;
for (int r = 0; r < 3; r++)
{
for (int c = 0; c < 3; c++)
{
sumX += srcPtr[c] * Sobel_3x3_X[r, c];
sumY += srcPtr[c] * Sobel_3x3_Y[r, c];
}
srcPtr = (byte *)srcPtr + frameStride;
}
//sumX >>= 3; sumY >>= 3; //divide by 8 (normalize kernel) //without this
var grad = sumX * sumX + sumY * sumY;
if (grad < minSqrMagnitude)
{
//magnitudeSqrImage[thread.Y + kernelRadius, thread.X + kernelRadius] = 0; //redundant
orientationImage[thread.Y + kernelRadius, thread.X + kernelRadius] = FeatureMap.INVALID_ORIENTATION;
}
else
{
magnitudeSqrImage[thread.Y + kernelRadius, thread.X + kernelRadius] = grad;
orientationImage[thread.Y + kernelRadius, thread.X + kernelRadius] = MathExtensions.Atan2Aprox(sumY, sumX);
}
}
private static void process(Action <KernelThread> kernel, int gridX, int gridY)
{
System.Threading.Tasks.Parallel.For(0, gridY, (j) =>
{
KernelThread th = new KernelThread();
th.Y = j;
for (int i = 0; i < gridX; i++)
{
th.X = i;
kernel(th);
}
});
}
private unsafe static void computeColor(KernelThread thread, byte *frame, int frameStride, Gray <int>[,] orientationImage, Gray <int>[,] magnitudeSqrImage, int minSqrMagnitude)
{
frame = frame + frameStride * thread.Y + thread.X;
int maxMagSqr = 0, maxDx = 0, maxDy = 0;
for (int ch = 0; ch < 3; ch++)
{
var srcPtr = frame + ch;
int sumX = 0, sumY = 0;
for (int r = 0; r < 3; r++)
{
var chPtr = srcPtr;
for (int c = 0; c < 3; c++)
{
sumX += *chPtr * Sobel_3x3_X[r, c];
sumY += *chPtr * Sobel_3x3_Y[r, c];
chPtr += 3 * sizeof(byte);
}
srcPtr = (byte *)srcPtr + frameStride;
}
//sumX >>= 3; sumY >>= 3; //divide by 8 (normalize kernel)
var grad = sumX * sumX + sumY * sumY;
if (grad > maxMagSqr)
{
maxMagSqr = grad;
maxDx = sumX;
maxDy = sumY;
}
}
if (maxMagSqr < minSqrMagnitude)
{
//magnitudeSqrImage[thread.Y + kernelRadius, thread.X + kernelRadius] = 0; //redundant
orientationImage[thread.Y + kernelRadius, thread.X + kernelRadius] = FeatureMap.INVALID_ORIENTATION;
}
else
{
magnitudeSqrImage[thread.Y + kernelRadius, thread.X + kernelRadius] = maxMagSqr;
orientationImage[thread.Y + kernelRadius, thread.X + kernelRadius] = MathExtensions.Atan2Aprox(maxDy, maxDx);
}
}
private unsafe static void kernelConvolve(KernelThread thread, float[,] input, float[,] output, float[,] kernel, IntPoint offset)
{
float sum = 0;
fixed(float *inputPtr = &input[thread.Y + offset.Y, thread.X + offset.X], kernelPtr = kernel)
{
for (int i = 0; i < 3; i++)
{
var y = thread.Y + i;
for (int j = 0; j < 3; j++)
{
sum += inputPtr[y + thread.X + j] * kernelPtr[j + i];
}
}
}
output[thread.Y, thread.X] = sum;
}
private static unsafe void computeGray(KernelThread thread, byte* frame, int frameStride, Gray<int>[,] orientationImage, Gray<int>[,] magnitudeSqrImage, int minSqrMagnitude)
{
frame = frame + frameStride * thread.Y + thread.X;
var srcPtr = frame;
int sumX = 0, sumY = 0;
for (int r = 0; r < 3; r++)
{
for (int c = 0; c < 3; c++)
{
sumX += srcPtr[c] * Sobel_3x3_X[r, c];
sumY += srcPtr[c] * Sobel_3x3_Y[r, c];
}
srcPtr = (byte*)srcPtr + frameStride;
}
//sumX >>= 3; sumY >>= 3; //divide by 8 (normalize kernel) //without this
var grad = sumX * sumX + sumY * sumY;
if (grad < minSqrMagnitude)
{
//magnitudeSqrImage[thread.Y + kernelRadius, thread.X + kernelRadius] = 0; //redundant
orientationImage[thread.Y + kernelRadius, thread.X + kernelRadius] = FeatureMap.INVALID_ORIENTATION;
}
else
{
magnitudeSqrImage[thread.Y + kernelRadius, thread.X + kernelRadius] = grad;
orientationImage[thread.Y + kernelRadius, thread.X + kernelRadius] = MathExtensions.Atan2Aprox(sumY, sumX);
}
}
private unsafe static void kernelConvert(KernelThread thread, float[,] input, float[,] output, float[,] kernel)
{
output[thread.Y, thread.X] = (float)Math.Sin(input[thread.Y, thread.X]) + 5;
}
