/// <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 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>
 /// 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>
 /// 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>
 /// 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>
 /// 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;
 }
 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>
 /// 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;
 }
 /// <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;
 }