I first became interested in C# image processing when I decided for some reason that I should write a program that would allow me to control a media player (e.g., Winamp) on my computer using a webcam and a laser pointer. This remains, to me, an interesting project, but it was simply too audacious for my skill level (and still is, to be honest, as I am but a beginner). One of the first problems I ran into in my naive approach was that using the Bitmap.Getpixel and Bitmap.Setpixel methods was ridiculously slow. Some quick googling revealed that what I needed was the magic of unsafe code and pointers. I quickly rewrote my functions, and was on my way.

A Different Approach

Recently, however, I discovered that there is a middle ground between unsafe code and the Getpixel and Setpixel methods which does not required the use of the unsafe keyword or pointers. I decided to give this a try to see how it performed, both objectively and subjectively.

The key thing to note here was that the Scan0 property of the BitmapData class is an IntPtr and not a pointer. This means that rather than dropping into an unsafe block, we can simply use the overloads of the System.Runtime.InteropServices.Marshal.Copy method to copy bytes to and from the location of the image in memory.

To test the performance of this method and the usual unsafe method, I wrote two methods which would each threshold an image. I also created a Windows form with a slider that would allow me to change the threshold value in real time, and watch how quickly the image responded (the subjective part of the test). The reasons I chose thresholding were that it’s often one of the first things done to an image during machine processing, and it’s simple to write. Aside from that, we’re really only interested in the time consumed by reading and writing the data to the image, which shouldn’t be affected by the operations perfomed on the data.

The first method, listed below, uses the IntPtr approach.

/*No unsafe keyword!*/
public Image ThresholdMA(float thresh)
{
    Bitmap b = new Bitmap(_image);

    BitmapData bData = b.LockBits(new Rectangle(0, 0, _image.Width, _image.Height), ImageLockMode.ReadWrite, b.PixelFormat);

    /* GetBitsPerPixel just does a switch on the PixelFormat and returns the number */
    byte bitsPerPixel = GetBitsPerPixel(bData.PixelFormat);

    /*the size of the image in bytes */
    int size = bData.Stride * bData.Height;

    /*Allocate buffer for image*/
    byte[] data = new byte[size];

    /*This overload copies data of /size/ into /data/ from location specified (/Scan0/)*/
    System.Runtime.InteropServices.Marshal.Copy(bData.Scan0, data, 0, size);

    for (int i = 0; i < size; i += bitsPerPixel / 8 )
    {
        double magnitude = 1/3d*(data[i] +data[i + 1] +data[i + 2]);
        if (magnitude < thresh)
        {
            data[i] = 0;
            data[i + 1] = 0;
            data[i + 2] = 0;
        }
        else
        {
            data[i] = 255;
            data[i + 1] = 255;
            data[i + 2] = 255;
        }
    }

    /* This override copies the data back into the location specified */
    System.Runtime.InteropServices.Marshal.Copy(data, 0, bData.Scan0, data.Length);

    b.UnlockBits(bData);

    return b;
}

The second method uses pointers.

/*Note unsafe keyword*/
public unsafe Image ThresholdUA(float thresh)
{
    Bitmap b = new Bitmap(_image);

    BitmapData bData = b.LockBits(new Rectangle(0, 0, _image.Width, _image.Height), ImageLockMode.ReadWrite, b.PixelFormat);

    byte bitsPerPixel = GetBitsPerPixel(bData.PixelFormat);

    /*This time we convert the IntPtr to a ptr*/
    byte* scan0 = (byte*)bData.Scan0.ToPointer();

    for (int i = 0; i < bData.Height; ++i)
    {
        for (int j = 0; j < bData.Width; ++j)
        {
            byte* data = scan0 + i * bData.Stride + j * bitsPerPixel / 8;

            double magnitude = 1/3d*(data[0] + data[1] + data[2]);
            /*Just write the data into memory*/
            if (magnitude < thresh)
            {
                data[0] = 0;
                data[1] = 0;
                data[2] = 0;
            }
            else
            {
                data[0] = 255;
                data[1] = 255;
                data[2] = 255;
            }
        }
    }

    b.UnlockBits(bData);

    return b;
}

That basically covers the code and approach. In Part II (tomorrow, I promise!!), I’ll post a full .sln and results of the comparison.

As previously discussed, LCD Smartie supports .Net plugins already. The requirements are that a public class be created with the name as LCDSmartie. This class can have up to 20 methods called funtion1-function20. These functions should take two strings, and return a string. (For more details, you can check out the instruction page for plugin authors.)

I wanted to be able to test the function which did the actual counting down, so I created a new solution as a console application, and then added a second project as a library that would actually do the countdown. Structuring the solution this way makes it so that both a .dll and an .exe are generated when the project is compiled.

My function1 looks like this:

public string function1(string a, string b)
{
    DateTime sunset = Sunset(DateTime.Now);

    if (DateTime.Compare(sunset, DateTime.Now) < 0)
        sunset = Sunset(new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day + 1));

    //doing this subtraction returns a TimeSpan object, whose ToString method I call
    return (sunset - DateTime.Now).ToString();

}

The return value of this function is a string representing the amount of time between now and sunset. If the sunset has already happened today (a very depressing turn of events indeed), it counts down till tomorrow’s sunset.

After testing my function using the the console application, the final step was to get LCD Smartie to call my function1 and send the output to the LCD. In line with the rest of the software’s philosophy, this was quite simple. All I had to do was copy the .dll to Smartie’s plugin directory, and then go to the configuration screen. The screen has a formidable look, but is quite simple. To get an item to display on a given line, you just enter that function on that line (my LCD has 4 lines, so there are 4 input boxes). The $dll function is used to call a .dll implementing the plugin interface. It takes 4 arguments: the dll name, the function number, and two strings that will be passed to the function. Below is a screenshot of my configuration screen.

One thing to note on this screen is I use the BigNum plugin to display multi-line numbers. The plugin is widely configurable, so I’ll refer you to their site for that information. And finally, a screenshot of LCD Smartie’s preview window. Unfortunately, I don’t have any pics of my actual timer available right now.

And finally, here is the code for LCD Smartie plugin. This is self-contained enough that I will just release the .cs file, but if you have any trouble configuring the solution or projects, let me know. For more complicated projects in the future, I will release full .slns. This code is in the public domain, but if you happen to do something interesting with it, or find it useful, it would be nice if you let me know.