I’ve added try catch with continue inside:
try
{
count++;

byte blue = p[0];
byte green = p[1];
byte red = p[2];

int pixelValue = Color.FromArgb(0, red, green, blue).ToArgb();
total += pixelValue;
double avg = total / count;
totalVariance += Math.Pow(pixelValue – avg, 2);
stdDev = Math.Sqrt(totalVariance / count);
p += bytesPerPixel;
}
catch
{
continue;
}

seems to have fixed the issue, but I still dont understand why some images will throw an error.

Times: What do you mean changing the hex to dec? all functions really on a byte not decimal value. Can you repost the decimal version?

Thanks

I am new to C# and need your help Chinch Do or Timex.
Some of the images(blank pages from both sides) when scanned get tested as blank while some are not blank, even though if they are blank.
Can u pls help with it.
If possible can u please give me some explanation on the code u or Timex have given.

Steve:

Thanks for your note and I think you are right. My algorithm does not produce a standard deviation number in the textbook definition. I think I used this modified “running” standard deviation algorithm to allow for this optimization: once the “running” standard deviation exceeds a certain threshold, I can short circuit the process and exit the loop. I do remember using this optimization but I guess I took it out at the end to keep the published code simple.

Chinh

[code]
///
/// Gets whether or not a given Bitmap is blank.
///
/// The instance of the Bitmap for this method extension.
/// Returns trueif the given Bitmap is blank; otherwise returns false.
public static bool IsBlank(this Bitmap bitmap) {
double stdDev = GetStdDev(bitmap);
int tolerance = 100000;
return stdDev < tolerance;
}

///
/// Gets the bits per pixel (bpp) for the given .
///
/// The instance of the for this method extension.
/// Returns a representing the bpp for the .
internal static byte GetBitsPerPixel(this Bitmap bitmap) {
byte bpp = 0x1;

//return Regex.Match(Regex.Match(bitmap.PixelFormat.ToString(), @"\dbpp").Value, @"\d+").Value;
switch (bitmap.PixelFormat) {
case PixelFormat.Format1bppIndexed:
bpp = 0x1;
break;
case PixelFormat.Format4bppIndexed:
bpp = 0x4;
break;
case PixelFormat.Format8bppIndexed:
bpp = 0x8;
break;
case PixelFormat.Format16bppArgb1555:
case PixelFormat.Format16bppGrayScale:
case PixelFormat.Format16bppRgb555:
case PixelFormat.Format16bppRgb565:
bpp = 0x16;
break;
case PixelFormat.Format24bppRgb:
bpp = 0x24;
break;
case PixelFormat.Canonical:
case PixelFormat.Format32bppArgb:
case PixelFormat.Format32bppPArgb:
case PixelFormat.Format32bppRgb:
bpp = 0x32;
break;
case PixelFormat.Format48bppRgb:
bpp = 0x48;
break;
case PixelFormat.Format64bppArgb:
case PixelFormat.Format64bppPArgb:
bpp = 0x64;
break;
}
return bpp;
}

///
/// Get the standard deviation of pixel values.
///
/// The instance of the for this method extension.
/// Returns the standard deviation of pixel population of the Bitmap.
public static double GetStdDev(this Bitmap bitmap) {
double total = 0;
double totalVariance = 0;
int count = 0;
double stdDev = 0;

// First get all the bytes
BitmapData bmData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
int stride = bmData.Stride;
IntPtr Scan0 = bmData.Scan0;

byte bitsPerPixel = GetBitsPerPixel(bitmap);
byte bytesPerPixel = (byte)(bitsPerPixel / 8);

unsafe {
byte* p = (byte*)(void*)Scan0;
int nOffset = stride - bitmap.Width * bytesPerPixel;
for (int y = 0; y < bitmap.Height; ++y) {
for (int x = 0; x < bitmap.Width; ++x) {
count++;

byte blue = p[0];
byte green = p[1];
byte red = p[2];

int pixelValue = Color.FromArgb(0, red, green, blue).ToArgb();
total += pixelValue;
double avg = total / count;
totalVariance += Math.Pow(pixelValue - avg, 2);
stdDev = Math.Sqrt(totalVariance / count);
p += bytesPerPixel;
}
p += nOffset;
}
}
bitmap.UnlockBits(bmData);

return stdDev;
}
[/code]

Note: I wrote this in C# 3.0, so these are extension methods, that way they appear as helper methods for the Bitmap type, like so:

[code]
using(Bitmap = new Bitmap(@"someimage.bmp")){
byte bpp = bitmap.GetBitsPerPixel();
int stddev = bitmap.GetStdDev();
bool isBlank = bitmap.IsBlank();
}
[/code]

In any event, I believe this should work for non-indexed bitmaps at least. I’m not sure about true indexed bitmaps.

Try it out and see if it works.

Chinh Do: You still get most of the credit, though! Much appreciated.