public double GetSum(IntegralImage2 image, int x, int y)
{
double sum = 0.0;
if (!Tilted)
{
// Compute the sum for a standard feature
foreach (HaarRectangle rect in Rectangles)
{
sum += image.GetSum(x + rect.ScaledX, y + rect.ScaledY,
rect.ScaledWidth, rect.ScaledHeight) * rect.ScaledWeight;
}
}
else
{
// Compute the sum for a rotated feature
foreach (HaarRectangle rect in Rectangles)
{
sum += image.GetSumT(x + rect.ScaledX, y + rect.ScaledY,
rect.ScaledWidth, rect.ScaledHeight) * rect.ScaledWeight;
}
}
return sum;
}
public bool Classify(IntegralImage2 image, int x, int y, double factor)
{
double value = 0;
foreach (HaarFeatureNode[] tree in Trees)
{
int current = 0;
do
{
HaarFeatureNode node = tree[current];
double sum = node.Feature.GetSum(image, x, y);
if (sum < node.Threshold * factor)
{
value += node.LeftValue;
current = node.LeftNodeIndex;
}
else
{
value += node.RightValue;
current = node.RightNodeIndex;
}
} while (current > 0);
}
if (value < this.Threshold)
{
return false;
}
else
{
return true;
}
}
public bool Compute(IntegralImage2 image, Rectangle rectangle)
{
int x = rectangle.X;
int y = rectangle.Y;
int w = rectangle.Width;
int h = rectangle.Height;
double mean = image.GetSum(x, y, w, h) * invArea;
double factor = image.GetSum2(x, y, w, h) * invArea - (mean * mean);
factor = (factor >= 0) ? Math.Sqrt(factor) : 1;
// For each classification stage in the cascade
foreach (HaarCascadeStage stage in cascade.Stages)
{
// Check if the stage has rejected the image
if (stage.Classify(image, x, y, factor) == false)
{
return false; // The image has been rejected.
}
}
return true; // The image has been detected.
}
public static IntegralImage2 FromBitmap(UnmanagedImage image, int channel, bool computeTilted)
{
if (!(image.PixelFormat == PixelFormat.Format8bppIndexed ||
image.PixelFormat == PixelFormat.Format24bppRgb ||
image.PixelFormat == PixelFormat.Format32bppArgb))
{
throw new UnsupportedImageFormatException("Only grayscale and 24 bpp RGB images are supported.");
}
int pixelSize = System.Drawing.Image.GetPixelFormatSize(image.PixelFormat) / 8;
int width = image.Width;
int height = image.Height;
int stride = image.Stride;
int offset = stride - width * pixelSize;
IntegralImage2 im = new IntegralImage2(width, height, computeTilted);
int* nSum = im.nSum, sSum = im.sSum, tSum = im.tSum;
int nWidth = im.nWidth, nHeight = im.nHeight;
int tWidth = im.tWidth, tHeight = im.tHeight;
if (image.PixelFormat == PixelFormat.Format8bppIndexed && channel != 0)
throw new ArgumentException("Only the first channel is available for 8 bpp images.", "channel");
byte* srcStart = (byte*)image.ImageData.ToPointer() + channel;
byte* src = srcStart;
for (int y = 1; y <= height; y++)
{
int yy = nWidth * (y);
int y1 = nWidth * (y - 1);
for (int x = 1; x <= width; x++, src += pixelSize)
{
int p1 = *src;
int p2 = p1 * p1;
int r = yy + (x);
int a = yy + (x - 1);
int b = y1 + (x);
int c = y1 + (x - 1);
nSum[r] = p1 + nSum[a] + nSum[b] - nSum[c];
sSum[r] = p2 + sSum[a] + sSum[b] - sSum[c];
}
src += offset;
}
if (computeTilted)
{
src = srcStart;
for (int y = 1; y <= height; y++, src += offset)
{
int yy = tWidth * (y);
int y1 = tWidth * (y - 1);
for (int x = 2; x < width + 2; x++, src += pixelSize)
{
int a = y1 + (x - 1);
int b = yy + (x - 1);
int c = y1 + (x - 2);
int r = yy + (x);
tSum[r] = *src + tSum[a] + tSum[b] - tSum[c];
}
}
{
int yy = tWidth * (height);
int y1 = tWidth * (height + 1);
for (int x = 2; x < width + 2; x++, src += pixelSize)
{
int a = yy + (x - 1);
int c = yy + (x - 2);
int b = y1 + (x - 1);
int r = y1 + (x);
tSum[r] = tSum[a] + tSum[b] - tSum[c];
}
}
for (int y = height; y >= 0; y--)
{
int yy = tWidth * (y);
int y1 = tWidth * (y + 1);
for (int x = width + 1; x >= 1; x--)
{
int r = yy + (x);
int b = y1 + (x - 1);
tSum[r] += tSum[b];
}
}
for (int y = height + 1; y >= 0; y--)
{
int yy = tWidth * (y);
for (int x = width + 1; x >= 2; x--)
{
int r = yy + (x);
int b = yy + (x - 2);
tSum[r] -= tSum[b];
}
}
}
return im;
}
