I recently had the need to get the background color of an image. The algorithm used to perform this is simple:
Get the image and find the color that occurs at least 3/4 of the time more than the next most occurring color in the image.
Here are some examples of images and what we would expect as a result.
The background image color is white.
The background image color is red.
The background image color is white.
Now, without further ado, here is the F# code. It should be relatively easy to follow.
Main.fs
open System open System.Text.RegularExpressions open System.IO open System.Windows.Forms open System.Windows.Forms.DataVisualization.Charting open System.Diagnostics [<EntryPoint>] let main (args: string[]) = let sw = new System.Diagnostics.Stopwatch() sw.Start() for i = 21 to 21 do let img = "C:\\Temp\\ImageSamples\\" + Convert.ToString(i) + ".jpg" // get the image let bitmap = new System.Drawing.Bitmap(img) // process image let background = AboutDev.ImageProcessing.GetBackgroundColor(bitmap) printfn "%A is: %i, %i, %i" i background.R background.G background.B bitmap.Dispose() sw.Stop() printfn "Time elapsed: %A" sw.Elapsed 0
ImageProcessing.fs
namespace AboutDev #light #nowarn "9" open System open Microsoft.FSharp.NativeInterop open Microsoft.FSharp.Collections open System.Drawing open System.Drawing.Imaging open System.Collections.Generic module ImageProcessing = begin let GetBackgroundColor (image:Bitmap) = // Get a Color from RGB values let GetColor x = Color.FromArgb(Convert.ToInt32(int16 (NativePtr.get x 0)) , Convert.ToInt32(int16 (NativePtr.get x 1)) , Convert.ToInt32(int16 (NativePtr.get x 2))) // Check for grayscale images let IsGrayscale (x:Color) = x.R < 128uy && x.G < 128uy && x.B < 128uy // Create a thumbnail only if the image is more that the allowable size of 300 * 300 pixels let ToThumbnailOrNot (b:Bitmap) = let maxAllowedDimensions = 300 // Create a thumbnail that is sized proportionately to the original let CreateThumbnail (b:Bitmap) = let maxPixels = 100.0 // compute the scaling factor of the original image to our max allowed pixels let scaling = if(b.Width > b.Height) then maxPixels / Convert.ToDouble(b.Width) else maxPixels / Convert.ToDouble(b.Height) // compute the size of the new image as a sequence let size = (Convert.ToInt32(Convert.ToDouble(b.Width) * scaling), Convert.ToInt32(Convert.ToDouble(b.Height) * scaling)) // create the thumbnail new System.Drawing.Bitmap(b.GetThumbnailImage(fst size, snd size, null, IntPtr.Zero)) if b.Width > maxAllowedDimensions && b.Height > maxAllowedDimensions then CreateThumbnail b else b // Get a thumbnail of the image if it is big or use the original image let img = ToThumbnailOrNot image // dispose the original image because a copy was made in the previous statement //image.Dispose() // The array that is going to contain argb values to then do counts on let items = List<int32>() // lockbits on image so that the image can be processed quicker using unsafe means let bd = img.LockBits(Rectangle(0,0,img.Width,img.Height),ImageLockMode.ReadWrite,PixelFormat.Format32bppArgb) // pointer to use to go through the image let mutable (p:nativeptr<byte>) = NativePtr.ofNativeInt (bd.Scan0) for i=0 to img.Height-1 do for j=0 to img.Width-1 do // Get the color of the [x,y] pixel let colo = (GetColor p).ToArgb() // add the ARGB value to our list items.Add(colo) // move to the next pixel on the row p <- NativePtr.add p 4 done // The stride - the whole length (multiplied by four to account for the fact that we are looking at 4 byte pixels p <- NativePtr.add p (bd.Stride - bd.Width*4) done // Unlock the image bytes img.UnlockBits(bd) // test code to see the image we worked on //img.Save("C:\\temp\\result.jpg", System.Drawing.Imaging.ImageFormat.Jpeg) // dispose the image that we worked on img.Dispose() //List.ofSeq items |> Seq.countBy id |> Seq.sortBy (fun x -> (~-)(snd x) ) |> Seq.take 10 |> Seq.iter (printfn "%A") // get the first two item that occur the most in the array as a sequence let res = List.ofSeq items |> Seq.countBy id |> Seq.sortBy (fun x -> (~-)(snd x) ) // Check to see that we have at least 2 colors if ( (Seq.length res) < 2) then res |> Seq.head |> fst |> Color.FromArgb else let zero = Seq.head res // first item in the sequence let one = Seq.nth 1 res // second item in the sequence // Get the most prominent color let background = fst zero |> Color.FromArgb let background2 = fst one |> Color.FromArgb // Make sure the image is not grayscale and // the background color occurs at least 3/4 as much as the next closest color if( (IsGrayscale background) || (((Convert.ToDouble (snd zero)) * 0.75) < (Convert.ToDouble (snd one)))) then //printfn "Cannot determine color" //printfn "First color is: %A, %A, %A" background.R background.G background.B //printfn "Second color is: %A, %A, %A" background2.R background2.G background2.B Color.Empty else //printfn "%A, %A, %A" background.R background.G background.B // Return the color background end // End Module
NOTE: The sample code above is just that, a sample. You will need to play with it to do your bidding.
To set this up this comparison, I had a sample size of 20 images. The original code without my algorithm optimizations took 31.62 seconds to run. The F# code took 0.78 seconds.
| Original Code | F# Code |
 |
 |
Optimizations I made over the original code:
1. Use of LockBits
2. Creating thumbnails of the original image to work on instead of the original image when that image is large.
During my testing, I also created an image that was 13,648 * 7,912 and it took [00:00:01.2340651] to process it in my F# code. I had to stop the original C# code running on that image after 10 min! When I implemented my algorithm in C#, I was able to get the speed of the 20 images to 7.88 seconds. Still faster in F#.
F# allowed me to play with the algorithm very easily and tweak away until I got it just right.
You have to love the power of a language that lets you focus on the algorithm rather than on the minutiae of the language.
Aboutdev's Weblog 