Images

Extension Method to Resize an Image

sweisfeld — Sun, 28 Jun 2009 23:52:00 GMT

I wrote this for an INETA project that I have been working on, but thought it would be great to share with everyone. We had a need to take an image and change its size. Below is an implementation of a Resize Extension Method on the .NET Image object.

I borrowed some ideas from this post by Mark McDonnell (http://weblogs.asp.net/markmcdonnell/archive/2008/03/09/resize-image-before-uploading-to-server.aspx)

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using System.Drawing;

   6:  using System.Drawing.Drawing2D;

7:

   8:  namespace Demo

   9:  {

  10:      public enum ResizeMode

  11:      {

  12:          Width,

  13:          Height,

  14:          Bigger

  15:      }

16:

  17:      public static class ImageHelper

  18:      {

  19:          public static Image Resize(this Image source, int size, ResizeMode mode)

  20:          {

  21:              //Convert the source image into a bitmap so we can work with it

  22:              Bitmap originalBMP = new Bitmap(source);

  23:              Image result;

24:

  25:              // Calculate the new image dimensions

  26:              int origWidth = originalBMP.Width;

  27:              int origHeight = originalBMP.Height;

  28:              int newWidth = 0;

  29:              int newHeight = 0;

30:

  31:              //If the size mode is set to bigger then find the widest side

  32:              if (mode == ResizeMode.Bigger)

  33:              {

  34:                  if (origHeight > origWidth)

  35:                      mode = ResizeMode.Height;

  36:                  else

  37:                      mode = ResizeMode.Width;

  38:              }

39:

  40:              //keeping the aspect ratio constant, calculate the new size

  41:              if (mode == ResizeMode.Width)

  42:              {

  43:                  newWidth = size;

  44:                  newHeight = (int)(size / ((double)origWidth / (double)origHeight));

  45:              }

  46:              else

  47:              {

  48:                  newHeight = size;

  49:                  newWidth = (int)(size / ((double)origHeight / (double)origWidth));

  50:              }

51:

52:

  53:              // Create a new bitmap which will hold the previous resized bitmap

  54:              Bitmap newBMP = new Bitmap(originalBMP, newWidth, newHeight);

55:

  56:              // Create a graphic based on the new bitmap

  57:              using (Graphics oGraphics = Graphics.FromImage(newBMP))

  58:              {

  59:                  // Set the properties for the new graphic file

  60:                  oGraphics.SmoothingMode = SmoothingMode.AntiAlias;

  61:                  oGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;

62:

  63:                  // Draw the new graphic based on the resized bitmap

  64:                  oGraphics.DrawImage(originalBMP, 0, 0, newWidth, newHeight);

65:

  66:                  // Save the new graphic file to the server

  67:                  result = newBMP.Clone() as Image;

68:

  69:                  // Once finished with the bitmap objects, we deallocate them.

  70:                  originalBMP.Dispose();

  71:                  newBMP.Dispose();

  72:                  oGraphics.Dispose();

  73:              }

74:

  75:              return result;

  76:          }

  77:      }

  78:  }

Using an extension method makes it really easy to use the new “resize” functionality:

   1:              Image img = Image.FromFile("img.jpg");

   2:              Image resized = img.Resize(100, ResizeMode.Bigger);

   3:              resized.Save("resized.jpg");

So we went from a source size of 2304x1728 and 782 KB

to 100x75 and 23.3 KB

Now you to can shrink the size of your memories. :)

Image Processing v2.1

sweisfeld — Tue, 18 Sep 2007 00:35:00 GMT

BTW to convert from the byte[] back to an image is simple enough

private Bitmap ConvertBitmap(byte[] frame, int width, int height)
{
Bitmap bmp = new Bitmap(
width,
height,
PixelFormat.Format24bppRgb);

BitmapData data = bmp.LockBits(
new Rectangle(0, 0, bmp.Width, bmp.Height),
ImageLockMode.WriteOnly,
PixelFormat.Format24bppRgb);

System.Runtime.InteropServices.Marshal.Copy(frame, 0, data.Scan0, frame.Length);

bmp.UnlockBits(data);
return bmp;
}

Image Processing v2

sweisfeld — Mon, 17 Sep 2007 22:47:00 GMT

I was tearing into v1.5 of Microsoft Robotics Studio (http://www.microsoft.com/robotics) and came across a novel way to process the pixels in an image. In previous posts I was using unmanaged C# code and pointers to move around the image. This worked well but is hard to manage. They take the approach of just dumping the entire image to a byte[], pure genius, now why did I not think of that. I will be rebuilding my library to utilize this technique but I thought this was so cool that I just had to share it!

/// <summary>
/// Coverts a bitmap to a byte[] then prints out the contents to a file
/// </summary>
public void PrintImage()
{
    string file = "image.bmp";
    Bitmap bitmap = Bitmap.FromFile(file) as Bitmap;
    byte[] frame = ConvertBitmap(bitmap);
    int height = bitmap.Height;
    int width = bitmap.Width;

    using (StreamWriter sWriter = new StreamWriter(file + ".txt"))
    {
        int offset;

//header
sWriter.WriteLine(string.Format("({0}, {1}) {2},{3},{4}", "COL", "ROW", "RED", "GREEN", "BLUE"));

        //loop over rows
        for (int y = 0; y < height; y++)
        {
            offset = y * width * 3;

            //loop ober columns
            for (int x = 0; x < width; x++, offset += 3)
            {
                int r, g, b;

                b = frame[offset];
                g = frame[offset + 1];
                r = frame[offset + 2];

                //pixel information
                sWriter.WriteLine(string.Format("({0}, {1}) {2},{3},{4}", x, y, r, g, b));
            }
        }
    }
}

/// <summary>
/// Convert a bitmap to a byte array
/// </summary>
/// <param name="bitmap">image to convert</param>
/// <returns>image as bytes</returns>
private byte[] ConvertBitmap(Bitmap bitmap)
{
    //Code excerpted from Microsoft Robotics Studio v1.5
    BitmapData raw = null; //used to get attributes of the image
    byte[] rawImage = null; //the image as a byte[]

    try
    {
        //Freeze the image in memory
        raw = bitmap.LockBits(
            new Rectangle(0, 0, (int)bitmap.Width, (int)bitmap.Height),
            ImageLockMode.ReadOnly,
            PixelFormat.Format24bppRgb
        );

int size = raw.Height * raw.Stride;
rawImage = new byte[size];

        //Copy the image into the byte[]
        System.Runtime.InteropServices.Marshal.Copy(raw.Scan0, rawImage, 0, size);
    }
    finally
    {
        if (raw != null)
        {
            //Unfreeze the memory for the image
            bitmap.UnlockBits(raw);
        }
    }
    return rawImage;
}

Tampa Code Camp Robot Vision Presentation

sweisfeld — Sat, 14 Jul 2007 08:35:00 GMT

Here is the powerpoint for my presentation tomorrow.

http://www.onetug.org/DNN/Portals/0/member_files/2007_07_14_robot.ppt

Bounding Box

sweisfeld — Mon, 14 May 2007 19:25:00 GMT

public static void BoundingBox(Bitmap b, ref Point upperLeft, ref Point lowerRight)
{
    ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
    Queue<Point> q = new Queue<Point>();
    q.Enqueue(upperLeft);

int jump = 10;

    while (q.Count > 0)
    {
     Point p = q.Dequeue();
     AddToStack(q, b, i, new Point(p.X + jump, p.Y), ref upperLeft, ref lowerRight);
     AddToStack(q, b, i, new Point(p.X - jump, p.Y), ref upperLeft, ref lowerRight);
     AddToStack(q, b, i, new Point(p.X, p.Y + jump), ref upperLeft, ref lowerRight);
     AddToStack(q, b, i, new Point(p.X, p.Y - jump), ref upperLeft, ref lowerRight);
    }
    i.UnlockBitmap();
}

private static void AddToStack(Queue<Point> q, Bitmap b, ImagerBitmap i, Point p, ref Point upperLeft, ref Point lowerRight)
{
    if (p.X < b.Width
     && p.Y < b.Height
     && i.GetGreyPixel(p.X, p.Y) != 0)
    {
     if (upperLeft.X > p.X)
     {
         upperLeft.X = p.X;
         q.Enqueue(p);
     }
     if (upperLeft.Y > p.Y)
     {
         upperLeft.Y = p.Y;
         q.Enqueue(p);
     }
     if (lowerRight.X < p.X)
     {
         lowerRight.X = p.X;
         q.Enqueue(p);
     }
     if (lowerRight.Y < p.Y)
     {
         lowerRight.Y = p.Y;
         q.Enqueue(p);
     }
    }
}

Center of Mass

sweisfeld — Mon, 14 May 2007 19:23:00 GMT

public static Point CenterOfMass(Bitmap b)
{
    ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
    int cogX = 0;
    int cogY = 0;
    int cogTotal = 0;

    for (int column = 0; column < i.Bitmap.Width; column++)
    {
     for (int row = 0; row < i.Bitmap.Height; row++)
     {
         int px = i.GetGreyPixel(column, row);
         cogX += (px * column);
         cogY += (px * row);
         cogTotal += px;
     }
    }
    i.UnlockBitmap();
    return new Point(cogX / cogTotal, cogY / cogTotal);
}

Remove Background

sweisfeld — Mon, 14 May 2007 19:15:00 GMT

In my earlier post I put together an image processing class (http://drowningintechnicaldebt.com/blogs/shawnweisfeld/archive/2006/11/06/Bitmap-Processing-in-C_2300_.aspx). I needed a method that did some segmentation based on a given color. It needed to take in the color and a threshold and it would black out any pixels that are not within the color threshold. Here is the code:

public static Bitmap RemoveBackground(Bitmap b, Color c, int threshold)
{
    ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
    int maxGreen = c.G + threshold;
    int minGreen = c.G - threshold;
    int maxRed = c.R + threshold;
    int minRed = c.R - threshold;
    int maxBlue = c.B + threshold;
    int minBlue = c.B - threshold;

    for (int column = 0; column < i.Bitmap.Width; column++)
    {
     for (int row = 0; row < i.Bitmap.Height; row++)
     {
         Color px = i.GetPixel(column, row);

         if (px.G > minGreen && px.G < maxGreen
          && px.R > minRed && px.R < maxRed
          && px.B > minBlue && px.B < maxBlue)
         {
          //i.SetPixel(column, row, Color.FromArgb(255, 255, 255));
         }
         else
         {
          i.SetPixel(column, row, Color.Black);
         }
     }
    }
    i.UnlockBitmap();
    return i.Bitmap.Clone() as Bitmap;
}

Stack Based Flood Fill Algorithm

sweisfeld — Mon, 04 Dec 2006 18:14:00 GMT

For a recent project I needed a Flood Fill Algorithm (see Flood Fill in Wikipedia, http://en.wikipedia.org/wiki/Flood_fill). Here is my implementation in C++.

Some things to note

1) I am using the ImagerBitmapClass from a previous post (http://drowningintechnicaldebt.com/blogs/shawnweisfeld/archive/2006/11/06/Bitmap-Processing-in-C_2300_.aspx), which I converted to C++

2) I am doing this fill in grey scale, you can easily change it to use full color objects

3) I am looking for all white objects, converting the first blob of white pixels to a given color, then moving to the next blob with a new color

marker = 100;
for (int row = 0; row < iright->GetBitmapHeight(); row++)
{
  for (int column = 0; column < iright->GetBitmapWidth(); column++)
  {
    if (iright->GetGreyPixel(column, row) == 255)
    {
      System::Collections::Generic::Queue<System::Drawing::Point> q = gcnew System::Collections::Generic::Queue<System::Drawing::Point>();
      q.Enqueue(System::Drawing::Point(column, row));
      iright->SetPixel(column, row, marker);
      while (q.Count > 0)
      {
        Point p = q.Dequeue();
        if (iright->AddToStack(p.X+1, p.Y, marker))
        {
          q.Enqueue(System::Drawing::Point(p.X+1, p.Y));
          iright->SetPixel(p.X+1, p.Y, marker);
        }
        if (iright->AddToStack(p.X, p.Y+1, marker))
        {
          q.Enqueue(System::Drawing::Point(p.X, p.Y+1));
          iright->SetPixel(p.X, p.Y+1, marker);
        }
        if (iright->AddToStack(p.X-1, p.Y, marker))
        {
          q.Enqueue(System::Drawing::Point(p.X-1, p.Y));
          iright->SetPixel(p.X-1, p.Y, marker);
        }
        if (iright->AddToStack(p.X, p.Y-1, marker))
        {
          q.Enqueue(System::Drawing::Point(p.X, p.Y-1));
          iright->SetPixel(p.X, p.Y-1, marker);
        }
      }
      marker += 20;
    }
  }
}
inline bool AddToStack(int x, int y, int marker)
{
  if ((x < 0) || (x >= this->GetBitmapWidth()))
  {
    return false;
  }
  if ((y < 0) || (y >= this->GetBitmapHeight()))
  {
    return false;
  }
  int px = this->GetGreyPixel(x, y);
  if (px == 255 && px != marker)
  {
    return true;
  }
  return false;
}

Bitmap Processing in C#

sweisfeld — Mon, 06 Nov 2006 19:18:00 GMT

Need to crack a bitmap and dittle around with its pixels? I know there is a managed get pixel property on the bitmap object but that is SLOW if you have to work with a lot of pixels. After some digging around I have compiled a few examples together to make my ImagerBitmap Class. The class uses unmanaged C# and pointers to iterate over the pixels in an image to do stuff. Since unmanaged code is inherently dangerous everything is made private and only some static functions that perform the image filters are exposed. Some of the functions included are: a color Laplace filter (Laplace filters are used for edge detection), a grayscale Laplace filter, a subtraction filter, a set of functions that allow you to extract only the red or blue or green pixels, a filter to allow you to convert the image to grayscale, a filter to allow you to convert the image to black and white, 3x3 and 5x5 versions of Box, Binomial and Median filters. In addition using ChartDirector (http://www.advsofteng.com/) the ability to generate charts of pixel data has been implemented. The charts include Grayscale & Color Histogram, Vertical and Horizontal scan line. Last but not least the ability to dump all the pixel information to a text file. Here is the code:

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using ChartDirector;
using System.IO;
namespace Imager2
{
    /// <summary>
    /// This class provides methods to Resize and Apply Filters to bitmap images.
    /// 
    /// ideas from 
    /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp11152001.asp
    /// http://www.msnewsgroups.net/group/microsoft.public.dotnet.languages.csharp/topic9351.aspx
    /// </summary>
    public unsafe class ImagerBitmap
    {
        /// <summary>
        /// This struct is used to hold the RGB values when we find a pixel using the pointer
        /// </summary>
        private struct PixelData
        {
            public byte Blue;
            public byte Green;
            public byte Red;
        }
        /// <summary>
        /// This object contains pointer addressable information about the bitmap
        /// </summary>
        private BitmapData _bitmapData = null;
        /// <summary>
        /// The pointer to the upper left corner of the bitmap
        /// </summary>
        private byte* pBase = null;
        private Bitmap _bitmap = null;
        /// <summary>
        /// Get the Image we are working with
        /// </summary>
        public Bitmap Bitmap
        {
            get 
            {
                return _bitmap; 
            }
        }
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="b">Bitmap to use as the basis of the Imager</param>
        private ImagerBitmap(Bitmap b)
        {
            if (b.PixelFormat != PixelFormat.Format24bppRgb)
            {
                //Convert the image into Format24bppRgb since our unmanaged code 
                //can walk that image type
                Bitmap b2 = new Bitmap(b.Size.Width, b.Size.Height, PixelFormat.Format24bppRgb);
                Graphics g = Graphics.FromImage(b2);
                g.DrawImage(b, new Point(0, 0));
                _bitmap = b2;
                g.Dispose();
            }
            else 
            {
                _bitmap = b;
            }
            LockBitmap();
        }
        /// <summary>
        /// Load a pixel with color
        /// </summary>
        /// <param name="x">Column</param>
        /// <param name="y">Row</param>
        /// <param name="c">Color</param>
        private void SetPixel(int x, int y, Color c)
        {
            PixelData* p = PixelAt(x, y);
            p->Red = c.R;
            p->Green = c.G;
            p->Blue = c.B;
        }
        /// <summary>
        /// Get a pixel
        /// </summary>
        /// <param name="x">Column</param>
        /// <param name="y">Row</param>
        /// <returns>Color</returns>
        private Color GetPixel(int x, int y)
        {
            PixelData* p = PixelAt(x, y);
            return Color.FromArgb((int)p->Red, (int)p->Green, (int)p->Blue);
        }
        /// <summary>
        /// Get the Grey value for a give pixel
        /// </summary>
        /// <param name="column">Column</param>
        /// <param name="row">Row</param>
        /// <returns>Grey value for the pixel</returns>
        private int GetGreyPixel(int column, int row)
        {
            return (int)((GetPixel(column, row).R * 0.3) + (GetPixel(column, row).G * 0.59) 
                + (GetPixel(column, row).B * 0.11));
        }
        /// <summary>
        /// Use the 2 most signifigant bits from each of the values in the RGB to get an in value 
        /// for the histogram
        /// </summary>
        /// <param name="column">Column</param>
        /// <param name="row">Row</param>
        /// <returns>Histogram Value</returns>
        public int GetRGBHistogramValue(int column, int row)
        {
            Color c = GetPixel(column, row);
            int val = 0;
            int tmp = 0;
            tmp = c.R;
            if (tmp - 128 > 0)
            {
                tmp -= 128;
                val += 32;
            }
            if (tmp - 64 > 0)
            {
                val += 16;
            }
            tmp = c.G;
            if (tmp - 128 > 0)
            {
                tmp -= 128;
                val += 8;
            }
            if (tmp - 64 > 0)
            {
                val += 4;
            }
            tmp = c.B;
            if (tmp - 128 > 0)
            {
                tmp -= 128;
                val += 2;
            }
            if (tmp - 64 > 0)
            {
                val += 1;
            }
            return val;
        }
        /// <summary>
        /// Lock the bitmap so we can use the pointers to access it
        /// </summary>
        private void LockBitmap()
        {
            _bitmapData = _bitmap.LockBits(new Rectangle(0, 0, _bitmap.Width, _bitmap.Height),
                                   ImageLockMode.ReadWrite, _bitmap.PixelFormat);
            pBase = (Byte*)_bitmapData.Scan0.ToPointer();
        }
        /// <summary>
        /// Get a pointer to a pixel
        /// </summary>
        /// <param name="x">Column</param>
        /// <param name="y">Row</param>
        /// <returns></returns>
        private unsafe PixelData* PixelAt(int x, int y)
        {
            return (PixelData*)(pBase + y * _bitmapData.Stride + x * sizeof(PixelData));
        }
        /// <summary>
        /// Unlock the bitmap to end the pointer access session
        /// </summary>
        private void UnlockBitmap()
        {
            _bitmap.UnlockBits(_bitmapData);
            _bitmapData = null;
            pBase = null;
        }
        /// <summary>
        /// Get a 3x3 matrix of the pixles around the center
        /// </summary>
        /// <param name="row">Center Row</param>
        /// <param name="column">Center Column</param>
        /// <returns>3x3 matrix of the pixles around the center</returns>
        private Color[,] Get3x3(int row, int column)
        {
            Color[,] c = new Color[3, 3];
            c[0, 0] = this.GetPixel(column - 1, row - 1);
            c[0, 1] = this.GetPixel(column - 1, row);
            c[0, 2] = this.GetPixel(column - 1, row + 1);
            c[1, 0] = this.GetPixel(column, row - 1);
            c[1, 1] = this.GetPixel(column, row);
            c[1, 2] = this.GetPixel(column, row + 1);
            c[2, 0] = this.GetPixel(column + 1, row - 1);
            c[2, 1] = this.GetPixel(column + 1, row);
            c[2, 2] = this.GetPixel(column + 1, row + 1);
            return c;
        }
        private int[,] GetGrey3x3(int row, int column)
        {
            int[,] c = new int[3, 3];
            c[0, 0] = this.GetGreyPixel(column - 1, row - 1);
            c[0, 1] = this.GetGreyPixel(column - 1, row);
            c[0, 2] = this.GetGreyPixel(column - 1, row + 1);
            c[1, 0] = this.GetGreyPixel(column, row - 1);
            c[1, 1] = this.GetGreyPixel(column, row);
            c[1, 2] = this.GetGreyPixel(column, row + 1);
            c[2, 0] = this.GetGreyPixel(column + 1, row - 1);
            c[2, 1] = this.GetGreyPixel(column + 1, row);
            c[2, 2] = this.GetGreyPixel(column + 1, row + 1);
            return c;
        }
        /// <summary>
        /// Get at 5x5 matrix of the pixels around the center
        /// </summary>
        /// <param name="row">Center Row</param>
        /// <param name="column">Center Column</param>
        /// <returns>5x5 matrix of pixles around center</returns>
        private Color[,] Get5x5(int row, int column)
        {
            Color[,] c = new Color[5, 5];
            c[0, 0] = this.GetPixel(column - 2, row - 2);
            c[0, 1] = this.GetPixel(column - 2, row - 1);
            c[0, 2] = this.GetPixel(column - 2, row);
            c[0, 3] = this.GetPixel(column - 2, row + 1);
            c[0, 4] = this.GetPixel(column - 2, row + 2);
            c[1, 0] = this.GetPixel(column - 1, row - 2);
            c[1, 1] = this.GetPixel(column - 1, row - 1);
            c[1, 2] = this.GetPixel(column - 1, row);
            c[1, 3] = this.GetPixel(column - 1, row + 1);
            c[1, 4] = this.GetPixel(column - 1, row + 2);
            c[2, 0] = this.GetPixel(column, row - 2);
            c[2, 1] = this.GetPixel(column, row - 1);
            c[2, 2] = this.GetPixel(column, row);
            c[2, 3] = this.GetPixel(column, row + 1);
            c[2, 4] = this.GetPixel(column, row + 2);
            c[3, 0] = this.GetPixel(column + 1, row - 2);
            c[3, 1] = this.GetPixel(column + 1, row - 1);
            c[3, 2] = this.GetPixel(column + 1, row);
            c[3, 3] = this.GetPixel(column + 1, row + 1);
            c[3, 4] = this.GetPixel(column + 1, row + 2);
            c[4, 0] = this.GetPixel(column + 2, row - 2);
            c[4, 1] = this.GetPixel(column + 2, row - 1);
            c[4, 2] = this.GetPixel(column + 2, row);
            c[4, 3] = this.GetPixel(column + 2, row + 1);
            c[4, 4] = this.GetPixel(column + 2, row + 2);
            return c;
        }
        /// <summary>
        /// Perform laplace edge detection on the image
        /// </summary>
        /// <param name="b">Source Image</param>
        /// <returns>Edges</returns>
        public static Bitmap Laplace(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            ImagerBitmap i2 = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 1; column < i.Bitmap.Width - 1; column++)
            {
                for (int row = 1; row < i.Bitmap.Height - 1; row++)
                {
                    Color[,] c = i.Get3x3(row, column);
                    int red = (((c[0, 0].R + c[0, 1].R + c[0, 2].R + c[1, 0].R + c[1, 2].R + c[2, 0].R 
                        + c[2, 1].R + c[2, 2].R) * -1)  + (c[1, 1].R * 8))+128;
                    int green = (((c[0, 0].G + c[0, 1].G + c[0, 2].G + c[1, 0].G + c[1, 2].G 
                        + c[2, 0].G + c[2, 1].G + c[2, 2].G) * -1) + (c[1, 1].G * 8))+128;
                    int blue = (((c[0, 0].B + c[0, 1].B + c[0, 2].B + c[1, 0].B + c[1, 2].B + c[2, 0].B 
                        + c[2, 1].B + c[2, 2].B) * -1) + (c[1, 1].B * 8))+128;
                    if (red >= 128) red = 0; else red = 255;
                    if (green >= 128) green = 0; else green = 255;
                    if (blue >= 128) blue = 0; else blue = 255;
                    i2.SetPixel(column, row, Color.FromArgb(red, green, blue));
                }
            }
            i.UnlockBitmap();
            i2.UnlockBitmap();
            return i2.Bitmap.Clone() as Bitmap;
        }
        public static Bitmap LaplaceGreyscale(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            ImagerBitmap i2 = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 1; column < i.Bitmap.Width - 1; column++)
            {
                for (int row = 1; row < i.Bitmap.Height - 1; row++)
                {
                    int[,] c = i.GetGrey3x3(row, column);
                    int val = (((c[0, 0] + c[0, 1] + c[0, 2] + c[1, 0] + c[1, 2] + c[2, 0] + c[2, 1] 
                        + c[2, 2]) * -1) + (c[1, 1] * 8)) + 128;
                    if (val >= 128) val = 0; else val = 255;
                    i2.SetPixel(column, row, Color.FromArgb(val, val, val));
                }
            }
            i.UnlockBitmap();
            i2.UnlockBitmap();
            return i2.Bitmap.Clone() as Bitmap;
        }

        /// <summary>
        /// Subtract b2 from b1 and normalize the image
        /// </summary>
        /// <param name="b1">Image</param>
        /// <param name="b2">Image</param>
        /// <returns>Normalized Image</returns>
        public static Bitmap Subtract(Bitmap b1, Bitmap b2)
        {
            if (b1.Width != b2.Width || b1.Height != b2.Height)
                throw new Exception("Images not the same size cannot subtract");
            ImagerBitmap i = new ImagerBitmap(b1.Clone() as Bitmap);
            ImagerBitmap i2 = new ImagerBitmap(b2.Clone() as Bitmap);
            int[,] red = new int[i.Bitmap.Width, i.Bitmap.Height];
            int[,] blue = new int[i.Bitmap.Width, i.Bitmap.Height];
            int[,] green = new int[i.Bitmap.Width, i.Bitmap.Height];
            int redMax = 0;
            int redMin = 0;
            int redRange = 0;
            int blueMax = 0;
            int blueMin = 0;
            int blueRange = 0;
            int greenMax = 0;
            int greenMin = 0;
            int greenRange = 0;
            //fill the arrays with the subtracted values
            //Keep track of the min and max values for later
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    Color c1 = i.GetPixel(column, row);
                    Color c2 = i2.GetPixel(column, row);
                    red[column, row] = c2.R - c1.R;
                    blue[column, row] = c2.B - c1.B;
                    green[column, row] = c2.G - c1.G;
                    if (red[column, row] > redMax) redMax = red[column, row];
                    if (red[column, row] < redMin) redMin = red[column, row];
                    if (blue[column, row] > blueMax) blueMax = blue[column, row];
                    if (blue[column, row] < blueMin) blueMin = blue[column, row];
                    if (green[column, row] > greenMax) greenMax = green[column, row];
                    if (green[column, row] < greenMin) greenMin = green[column, row];
                }
            }
            //find the range of the min an max
            redRange = Math.Abs(redMax - redMin);
            blueRange = Math.Abs(blueMax - blueMin);
            greenRange = Math.Abs(greenRange - greenMin);
            //Normalize the values in the arrays and load the result image
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    if (redRange != 0)
                         red[column, row] = 255 - (((redMax - red[column, row]) * 255) / redRange);
                    if (blueRange != 0)
                        blue[column, row] = 255 - (((blueMax - blue[column, row]) * 255) / blueRange);
                    if (greenRange != 0)
                        green[column, row] = 255 - (((greenMax - green[column, row]) * 255) / greenRange);
                    if (red[column, row] < 0)
                        red[column, row] = 0;
                    if (blue[column, row] < 0)
                        blue[column, row] = 0;
                    if (green[column, row] < 0)
                        green[column, row] = 0;
                    i2.SetPixel(column, row, Color.FromArgb(red[column, row], green[column, row], 
                        blue[column, row]));
                }
            }
            i.UnlockBitmap();
            i2.UnlockBitmap();
            return i2.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Get the red pixels from the bitmap
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap GetRedBitmap(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    i.SetPixel(column, row, Color.FromArgb(i.GetPixel(column, row).R, 0, 0));
                }
            }
            i.UnlockBitmap();
            return i.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Get the Blue Pixes from the bitmap
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap GetBlueBitmap(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    i.SetPixel(column, row, Color.FromArgb(0, 0, i.GetPixel(column, row).B));
                }
            }
            i.UnlockBitmap();
            return i.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Get the green pixels from the image
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap GetGreenBitmap(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    i.SetPixel(column, row, Color.FromArgb(0, i.GetPixel(column, row).G, 0));
                }
            }
            i.UnlockBitmap();
            return i.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Make the image Grey scale
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap GetGreyScaleBitmap(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    int val = i.GetGreyPixel(column, row);
                    i.SetPixel(column, row, Color.FromArgb(val, val, val));
                }
            }
            i.UnlockBitmap();
            return i.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Make the image black and white
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap GetBlackAndWhiteBitmap(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            double[] histogram = new double[256];
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    histogram[i.GetGreyPixel(column, row)]++;
                }
            }
            //find the position of the max value on the left
            int leftK = 0;
            for (int k = 0; k < 128; k++)
            {
                if (histogram[k] > histogram[leftK]) leftK = k;
            }
            //find the position of the max value on the right
            int rightK = 0;
            for (int k = 128; k < 256; k++)
            {
                if (histogram[k] > histogram[rightK]) rightK = k;
            }
            //find the min value between the 2 local maxes
            int localMin = rightK;
            for (int k = leftK; k < rightK; k++)
            {
                if (histogram[k] < histogram[localMin]) localMin = k;
            }
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    int val = (i.GetPixel(column, row).R + i.GetPixel(column, row).G 
                        + i.GetPixel(column, row).B) / 3;
                    if (val > localMin)
                        val = 255;
                    else
                        val = 0;
                    i.SetPixel(column, row, Color.FromArgb(val, val, val));
                }
            }
            i.UnlockBitmap();
            return i.Bitmap.Clone() as Bitmap;
        }
        public static Bitmap GetBlackAndWhiteBitmap2(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            double[] histogram = new double[256];
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    histogram[i.GetGreyPixel(column, row)]++;
                }
            }
            double k = b.Width * b.Height;
            double half = k / 2;
            int middle = 0;
            while (k > half)
            {
                k = k - histogram[middle];
                middle++;
            }
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    int val = (i.GetPixel(column, row).R + i.GetPixel(column, row).G 
                        + i.GetPixel(column, row).B) / 3;
                    if (val > middle)
                        val = 255;
                    else
                        val = 0;
                    i.SetPixel(column, row, Color.FromArgb(val, val, val));
                }
            }
            i.UnlockBitmap();
            return i.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Perform a Box filter using a 3x3 Mask
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap Box3x3(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            ImagerBitmap i2 = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 1; column < i.Bitmap.Width - 1; column++)
            {
                for (int row = 1; row < i.Bitmap.Height - 1; row++)
                {
                    Color[,] c = i.Get3x3(row, column);
                    int red = (c[0, 0].R + c[0, 1].R + c[0, 2].R + c[1, 0].R + c[1, 2].R + c[2, 0].R 
                        + c[2, 1].R + c[2, 2].R + c[1, 1].R) / 9;
                    int green = (c[0, 0].G + c[0, 1].G + c[0, 2].G + c[1, 0].G + c[1, 2].G + c[2, 0].G 
                        + c[2, 1].G + c[2, 2].G + c[1, 1].G) / 9;
                    int blue = (c[0, 0].B + c[0, 1].B + c[0, 2].B + c[1, 0].B + c[1, 2].B + c[2, 0].B 
                        + c[2, 1].B + c[2, 2].B + c[1, 1].B) / 9;
                    i2.SetPixel(column, row, Color.FromArgb(red, green, blue));
                }
            }
            i.UnlockBitmap();
            i2.UnlockBitmap();
            return i2.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Perform a Bionomial filter using a 3x3 Mask
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap Binomial3x3(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            ImagerBitmap i2 = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 1; column < i.Bitmap.Width - 1; column++)
            {
                for (int row = 1; row < i.Bitmap.Height - 1; row++)
                {
                    Color[,] c = i.Get3x3(row, column);
                    int red = ((c[0, 0].R * 1) + (c[0, 1].R * 2) + (c[0, 2].R * 1) + (c[1, 0].R * 2) 
                        + (c[1, 1].R * 4) + (c[1, 2].R * 2) + (c[2, 0].R * 1) + (c[2, 1].R * 2) 
                        + (c[2, 2].R * 1)) / 16;
                    int green = ((c[0, 0].G * 1) + (c[0, 1].G * 2) + (c[0, 2].G * 1) + (c[1, 0].G * 2) 
                        + (c[1, 1].G * 4) + (c[1, 2].G * 2) + (c[2, 0].G * 1) + (c[2, 1].G * 2) 
                        + (c[2, 2].G * 1)) / 16;
                    int blue = ((c[0, 0].B * 1) + (c[0, 1].B * 2) + (c[0, 2].B * 1) + (c[1, 0].B * 2) 
                        + (c[1, 1].B * 4) + (c[1, 2].B * 2) + (c[2, 0].B * 1) + (c[2, 1].B * 2) 
                        + (c[2, 2].B * 1)) / 16; 
                    i2.SetPixel(column, row, Color.FromArgb(red, green, blue));
                }
            }
            i.UnlockBitmap();
            i2.UnlockBitmap();
            return i2.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Perform a Median filter using a 3x3 mask
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap Median3x3(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            ImagerBitmap i2 = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 1; column < i.Bitmap.Width - 1; column++)
            {
                for (int row = 1; row < i.Bitmap.Height - 1; row++)
                {
                    Color[,] c = i.Get3x3(row, column);
                    int red = Median(c[0, 0].R, c[0, 1].R, c[0, 2].R, c[1, 0].R, c[1, 1].R, c[1, 2].R, 
                        c[2, 0].R, c[2, 1].R, c[2, 2].R);
                    int green = Median(c[0, 0].G, c[0, 1].G, c[0, 2].G, c[1, 0].G, c[1, 1].G, 
                        c[1, 2].G, c[2, 0].G, c[2, 1].G, c[2, 2].G);
                    int blue = Median(c[0, 0].B, c[0, 1].B, c[0, 2].B, c[1, 0].B, c[1, 1].B, c[1, 2].B, 
                        c[2, 0].B, c[2, 1].B, c[2, 2].B);
                    i2.SetPixel(column, row, Color.FromArgb(red, green, blue));
                }
            }
            i.UnlockBitmap();
            i2.UnlockBitmap();
            return i2.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Perform a Box filter using a 5x5 Mask
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap Box5x5(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            ImagerBitmap i2 = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 2; column < i.Bitmap.Width - 2; column++)
            {
                for (int row = 2; row < i.Bitmap.Height - 2; row++)
                {
                    Color[,] c = i.Get5x5(row, column);
                    int red = (c[0, 0].R + c[0, 1].R + c[0, 2].R + c[0, 3].R + c[0, 4].R + c[1, 0].R 
                        + c[1, 1].R + c[1, 2].R + c[1, 3].R + c[1, 4].R + c[2, 0].R + c[2, 1].R 
                        + c[2, 2].R + c[2, 3].R + c[2, 4].R + c[3, 0].R + c[3, 1].R + c[3, 2].R 
                        + c[3, 3].R + c[3, 4].R + c[4, 0].R + c[4, 1].R + c[4, 2].R + c[4, 3].R 
                        + c[4, 4].R) / 25;
                    int green = (c[0, 0].G + c[0, 1].G + c[0, 2].G + c[0, 3].G + c[0, 4].G + c[1, 0].G 
                        + c[1, 1].G + c[1, 2].G + c[1, 3].G + c[1, 4].G + c[2, 0].G + c[2, 1].G 
                        + c[2, 2].G + c[2, 3].G + c[2, 4].G + c[3, 0].G + c[3, 1].G + c[3, 2].G 
                        + c[3, 3].G + c[3, 4].G + c[4, 0].G + c[4, 1].G + c[4, 2].G + c[4, 3].G 
                        + c[4, 4].G) / 25;
                    int blue = (c[0, 0].B + c[0, 1].B + c[0, 2].B + c[0, 3].B + c[0, 4].B + c[1, 0].B 
                        + c[1, 1].B + c[1, 2].B + c[1, 3].B + c[1, 4].B + c[2, 0].B + c[2, 1].B 
                        + c[2, 2].B + c[2, 3].B + c[2, 4].B + c[3, 0].B + c[3, 1].B + c[3, 2].B 
                        + c[3, 3].B + c[3, 4].B + c[4, 0].B + c[4, 1].B + c[4, 2].B + c[4, 3].B 
                        + c[4, 4].B) / 25;
                    i2.SetPixel(column, row, Color.FromArgb(red, green, blue));
                }
            }
            i.UnlockBitmap();
            i2.UnlockBitmap();
            return i2.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Perform a Binomial filter using a 5x5 Mask
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap Binomial5x5(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            ImagerBitmap i2 = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 2; column < i.Bitmap.Width - 2; column++)
            {
                for (int row = 2; row < i.Bitmap.Height - 2; row++)
                {
                    Color[,] c = i.Get5x5(row, column);
                    int red = ((c[0, 0].R * 1) + (c[0, 1].R * 4) + (c[0, 2].R * 6) + (c[0, 3].R * 4) 
                        + (c[0, 4].R * 1) + (c[1, 0].R * 4) + (c[1, 1].R * 16) + (c[1, 2].R * 24) 
                        + (c[1, 3].R * 16) + (c[1, 4].R * 4) + (c[2, 0].R * 6) + (c[2, 1].R * 24) 
                        + (c[2, 2].R * 36) + (c[2, 3].R * 24) + (c[2, 4].R * 6) + (c[3, 0].R * 4) 
                        + (c[3, 1].R * 16) + (c[3, 2].R * 24) + (c[3, 3].R * 16) + (c[3, 4].R * 4) 
                        + (c[4, 0].R * 1) + (c[4, 1].R * 4) + (c[4, 2].R * 6) + (c[4, 3].R * 4) 
                        + (c[4, 4].R * 1)) / 256;
                    int green = ((c[0, 0].G * 1) + (c[0, 1].G * 4) + (c[0, 2].G * 6) + (c[0, 3].G * 4) 
                        + (c[0, 4].G * 1) + (c[1, 0].G * 4) + (c[1, 1].G * 16) + (c[1, 2].G * 24) 
                        + (c[1, 3].G * 16) + (c[1, 4].G * 4) + (c[2, 0].G * 6) + (c[2, 1].G * 24) 
                        + (c[2, 2].G * 36) + (c[2, 3].G * 24) + (c[2, 4].G * 6) + (c[3, 0].G * 4) 
                        + (c[3, 1].G * 16) + (c[3, 2].G * 24) + (c[3, 3].G * 16) + (c[3, 4].G * 4) 
                        + (c[4, 0].G * 1) + (c[4, 1].G * 4) + (c[4, 2].G * 6) + (c[4, 3].G * 4) 
                        + (c[4, 4].G * 1)) / 256;
                    int blue = ((c[0, 0].B * 1) + (c[0, 1].B * 4) + (c[0, 2].B * 6) + (c[0, 3].B * 4) 
                        + (c[0, 4].B * 1) + (c[1, 0].B * 4) + (c[1, 1].B * 16) + (c[1, 2].B * 24) 
                        + (c[1, 3].B * 16) + (c[1, 4].B * 4) + (c[2, 0].B * 6) + (c[2, 1].B * 24) 
                        + (c[2, 2].B * 36) + (c[2, 3].B * 24) + (c[2, 4].B * 6) + (c[3, 0].B * 4) 
                        + (c[3, 1].B * 16) + (c[3, 2].B * 24) + (c[3, 3].B * 16) + (c[3, 4].B * 4)
                        + (c[4, 0].B * 1) + (c[4, 1].B * 4) + (c[4, 2].B * 6) + (c[4, 3].B * 4) 
                        + (c[4, 4].B * 1)) / 256;
                    i2.SetPixel(column, row, Color.FromArgb(red, green, blue));
                }
            }
            i.UnlockBitmap();
            i2.UnlockBitmap();
            return i2.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Perform a Median fiter using a 5x5 Mask
        /// </summary>
        /// <param name="b">Image to Process</param>
        /// <returns>Filtered Image</returns>
        public static Bitmap Median5x5(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            ImagerBitmap i2 = new ImagerBitmap(b.Clone() as Bitmap);
            for (int column = 2; column < i.Bitmap.Width - 2; column++)
            {
                for (int row = 2; row < i.Bitmap.Height - 2; row++)
                {
                    Color[,] c = i.Get5x5(row, column);
                    int red = Median(c[0, 0].R, c[0, 1].R, c[0, 2].R, c[0, 3].R, c[0, 4].R, c[1, 0].R, 
                        c[1, 1].R, c[1, 2].R, c[1, 3].R, c[1, 4].R, c[2, 0].R, c[2, 1].R, c[2, 2].R, 
                        c[2, 3].R, c[2, 4].R, c[3, 0].R, c[3, 1].R, c[3, 2].R, c[3, 3].R, c[3, 4].R, 
                        c[4, 0].R, c[4, 1].R, c[4, 2].R, c[4, 3].R, c[4, 4].R);
                    int green = Median(c[0, 0].G, c[0, 1].G, c[0, 2].G, c[0, 3].G, c[0, 4].G, c[1, 0].G,
                        c[1, 1].G, c[1, 2].G, c[1, 3].G, c[1, 4].G, c[2, 0].G, c[2, 1].G, c[2, 2].G, 
                        c[2, 3].G, c[2, 4].G, c[3, 0].G, c[3, 1].G, c[3, 2].G, c[3, 3].G, c[3, 4].G, 
                        c[4, 0].G, c[4, 1].G, c[4, 2].G, c[4, 3].G, c[4, 4].G);
                    int blue = Median(c[0, 0].B, c[0, 1].B, c[0, 2].B, c[0, 3].B, c[0, 4].B, c[1, 0].B, 
                        c[1, 1].B, c[1, 2].B, c[1, 3].B, c[1, 4].B, c[2, 0].B, c[2, 1].B, c[2, 2].B, 
                        c[2, 3].B, c[2, 4].B, c[3, 0].B, c[3, 1].B, c[3, 2].B, c[3, 3].B, c[3, 4].B, 
                        c[4, 0].B, c[4, 1].B, c[4, 2].B, c[4, 3].B, c[4, 4].B);
                    i2.SetPixel(column, row, Color.FromArgb(red, green, blue));
                }
            }
            i.UnlockBitmap();
            i2.UnlockBitmap();
            return i2.Bitmap.Clone() as Bitmap;
        }
        /// <summary>
        /// Find the Median value in an array of int's
        /// </summary>
        /// <param name="values">Array of values</param>
        /// <returns>Median value</returns>
        private static int Median(params int[] values)
        {
            Array.Sort(values);
            return values[((values.Length - 1) / 2) + 1];
        }
        /// <summary>
        /// Resize an image
        /// </summary>
        /// <param name="b">Image to resize</param>
        /// <param name="width">Width in pixels</param>
        /// <param name="height">Height in pixels</param>
        /// <returns>New Image</returns>
        public static Bitmap Resize(Bitmap b, int width, int height)
        {
            Bitmap b2 = new Bitmap(width, height, PixelFormat.Format24bppRgb);
            Graphics g = Graphics.FromImage(b2);
            g.DrawImage(b, new Rectangle(0, 0, width, height), 0, 0, b.Width, b.Height, 
                GraphicsUnit.Pixel);
            g.Dispose();
            return b2;
        }
        /// <summary>
        /// Generate a greyscale histogram chart from the bitmap
        /// </summary>
        /// <param name="b">Image to use</param>
        /// <returns>Histogram chart</returns>
        public static Bitmap GenerateGreyscaleHistogram(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            double[] histogram = new double[256];
            string[] lbls = new string[256];
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    histogram[i.GetGreyPixel(column, row)]++;
                }
            }
            i.UnlockBitmap();
            for (int j = 0; j < 256; j++)
            {
                if ((j % 30) == 0)
                {
                    lbls[j] = j.ToString();
                }
                else
                {
                    lbls[j] = string.Empty;
                }
            }
            XYChart c = new XYChart(b.Width + 60, b.Height + 60);
            c.setPlotArea(40, 40, b.Width - 20, b.Height - 20);
            c.addTitle("Greyscale Historgram", "Arial Bold", 10).setBackground(
                Chart.metalColor(0x9999ff), -1, 1);
            c.addBarLayer(histogram);
            c.xAxis().setLabels(lbls);
            return c.makeImage() as Bitmap;
        }
        /// <summary>
        /// Generate a histogram chart from the bitmap
        /// </summary>
        /// <param name="b">Image to use</param>
        /// <returns>Histogram chart</returns>
        public static Bitmap GenerateHistogram(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            double[] histogram = new double[64];
            string[] lbls = new string[64];
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                for (int row = 0; row < i.Bitmap.Height; row++)
                {
                    histogram[i.GetRGBHistogramValue(column, row)]++;
                }
            }
            i.UnlockBitmap();
            for (int j = 0; j < 64; j++)
            {
                if ((j % 10) == 0)
                {
                    lbls[j] = j.ToString();
                }
                else
                {
                    lbls[j] = string.Empty;
                }
            }
            XYChart c = new XYChart(b.Width + 60, b.Height + 60);
            c.setPlotArea(40, 40, b.Width - 20, b.Height - 20);
            c.addTitle("Color Historgram", "Arial Bold", 10).setBackground(
                Chart.metalColor(0x9999ff), -1, 1);
            c.addBarLayer(histogram);
            c.xAxis().setLabels(lbls);
            return c.makeImage() as Bitmap;
        }
        /// <summary>
        /// Generate a Chart of a Scan line
        /// </summary>
        /// <param name="b">Image to use</param>
        /// <param name="row">Row to use</param>
        /// <returns>Scan Line Chart</returns>
        public static Bitmap GenerateScanLineChart(Bitmap b, int row)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            double[] luminance = new double[b.Width];
            string[] lbls = new string[b.Width];
            double max = double.MinValue;
            double min = double.MaxValue;
            for (int column = 0; column < i.Bitmap.Width; column++)
            {
                luminance[column] = i.GetGreyPixel(column, row);
                if (luminance[column] > max) max = luminance[column];
                if (luminance[column] < min) min = luminance[column];
                if ((column % 40) == 0)
                {
                    lbls[column] = column.ToString();
                }
                else 
                {
                    lbls[column] = string.Empty;
                }
            }
            i.UnlockBitmap();
            XYChart c = new XYChart(b.Width + 60, b.Height + 60);
            c.setPlotArea(40, 40, b.Width - 20, b.Height - 20);
            c.addTitle(string.Format("Pixel Luminance for Scan Line {0}, STF {1:0.00}", 
                row.ToString(),
                (max - min) / (max + min)), "Arial Bold", 10).setBackground(
                Chart.metalColor(0x9999ff), -1, 1);
            c.addLineLayer(luminance);
            c.xAxis().setLabels(lbls);
            return c.makeImage() as Bitmap;
        }
        /// <summary>
        /// Generate a Chart of a Vertical Scan line
        /// </summary>
        /// <param name="b">Image to use</param>
        /// <param name="column">Column to use</param>
        /// <returns>Scan Line Chart</returns>
        public static Bitmap GenerateVerticalScanLineChart(Bitmap b, int col)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            double[] luminance = new double[b.Height];
            string[] lbls = new string[b.Height];
            for (int row = 0; row < i.Bitmap.Height; row++)
            {
                luminance[row] = i.GetGreyPixel(col, row);
                if ((row % 40) == 0)
                {
                    lbls[row] = row.ToString();
                }
                else
                {
                    lbls[row] = string.Empty;
                }
            }
            i.UnlockBitmap();
            XYChart c = new XYChart(b.Width + 60, b.Height + 60);
            c.setPlotArea(40, 40, b.Width - 20, b.Height - 20);
            c.addTitle("Pixel Luminance for Vertical Scan Line " + col.ToString(), 
                "Arial Bold", 10).setBackground(
                Chart.metalColor(0x9999ff), -1, 1);
            c.addLineLayer(luminance);
            c.xAxis().setLabels(lbls);
            return c.makeImage() as Bitmap;
        }
        public static void GenerateExcelFile(Bitmap b)
        {
            ImagerBitmap i = new ImagerBitmap(b.Clone() as Bitmap);
            string fileName = "output.txt";
            int f = 0;
            using (StreamWriter sw = new StreamWriter(fileName, false))
            {
                sw.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}", "Index", "Row", "Column", "Red", 
                    "Green", "Blue", "Gray");
                for (int column = 0; column < i.Bitmap.Width; column++)
                {
                    for (int row = 0; row < i.Bitmap.Height; row++)
                    {
                        f++;
                        Color c = i.GetPixel(column, row);
                        int g = i.GetGreyPixel(column, row);
                        sw.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}", f, 
                            row, column, c.R, c.G, c.B, g);
                    }
                }
            }
            i.UnlockBitmap();
            System.Diagnostics.Process.Start(fileName);
        }
    }
}