Very simple conversion of bitmap to indexed bitmap

No effort, no explanation, not the way to write code.

I understand why this looks like no good code, conform to today's architectural rules.
Yes, this is only bare metal, the base necessity.
But for me, just what it should be, when tagged with a label "tip/trick".
Code like this is just made for speed, and saving resources like intermediate memory streams or files.
It just brings together some not well documented stuff.
Even the used unsafe memory pointers just showed how simple it is doing high speed parsing over the bits in the bitmap.

Sometimes there are big commented source projects, complete with test classes and over documented. But then I have to strip down to what I need.
This is only a building block, which can be decorated any way.

So in its own category, it is a very useable tip/trick.

You are correct that there's not a lot of documentation on this subject. I think one might be skeptical using code that's "unsafe", thinking that the unsafe keyword itself might be malicious. The reason the unsafe memory pointers are faster is because they directly access the memory address, where the Get Pixel/Set Pixel is extremely slow because it Marshals(System.Runtime.InteropServices.Marshal.Copy) each call to the memory address which results in very slow performance and eventually runs out of memory, especially with larger Bitmaps.

As mentioned, I run code on Linux, options are limited, unless you build a suitable wrapper around pInvoke. I'm self taught and a little outside of my reach, but always willing to share any knowledge to help anyone looking for the same basic concept.

modified 12-Apr-23 22:28pm.

Oh, where to begin...

A tip is only useful if it's intended target audience is specified. No where in this tip is the target specified as Windows Forms, and worse, no where have you specified that its Windows Forms under .NET Framework as opposed to .NET Core. This all needs to be inferred, and for those of us with mileage under our belts, we would never present code in this fashion. That's just for openers.

The code does not compile as is. No where are the proper using statements specified:

C#

using System.Drawing;
using System.Drawing.Imaging;

In addition, those who have not used unsafe code will not know how/where to set the proper flags to compile the code under Project->Properties->Build.

The comes the code itself, which is a ticking timebomb due to improper handling of resources and error handling. There are two major violations of best practices here:

Never return an object that implements an IDisposable pattern i.e. requires garbage collection
Never implement a method with objects that contain lifetime resources without exception handling

I have taken the liberty of rewriting your "tip" to conform to address the two violations as follows:

C#

private static void ToIndexed(Bitmap source, PixelFormat format, out Bitmap result)
   {
       result = null;
       try
       {
           unsafe
           {
               Rectangle rectangle = new Rectangle(0, 0, source.Width, source.Height);
               result = new Bitmap(source.Width, source.Height, format);

               BitmapData sourceData = source.LockBits(rectangle,
                       ImageLockMode.ReadOnly, source.PixelFormat),
                   resultData = result.LockBits(rectangle,
                       ImageLockMode.WriteOnly, format);

               int sourceFlags = sourceData.Stride * sourceData.Height,
                   resultFlags = resultData.Stride * resultData.Height;

               byte* sourceBuffer = (byte*)sourceData.Scan0.ToPointer(),
                   resultBuffer = (byte*)resultData.Scan0.ToPointer();

               int offset = sourceFlags / resultFlags;
               for (int i = 0; i < sourceFlags; i++)
               {
                   resultBuffer[i / offset] = sourceBuffer[i];
               }

               result.UnlockBits(resultData);
               source.UnlockBits(sourceData);
           }

       }
       catch (Exception e)
       {
           result?.Dispose();
           throw;
       }
   }

I wrote a quick console application that shows how one might call your method:

C#

static void Main(string[] args)
{
    try
    {
        using (Bitmap bm = new Bitmap(10, 10))
        {
            Bitmap res;
            ToIndexed(bm, PixelFormat.Alpha, res);

                . . . .

        }
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
        throw;
    }
}

One more point... this code is brittle, in that bitmap integer size will vary from machine to machine, and from processor to processor. In fact, given the prevalence or Mono, and the continued portability or .NET on platforms such as Xamarin, where this can run on Processors where 'endian'ness cannot be assured, this code is quite brittle indeed.

None of this is pointed out in either code comments or in accompanying text. The reason for my vote of '1' is not for the type of submission, but rather for what seems to be a 'phoning it in' type of effort. Even tips require some modicum of time and preparation. I almost feel like I spent more time and effort answering you, than you did posting your tip in the first place.

C#

PixelFormat fastFormat = PixelFormat.Format4bppIndexed;
            Bitmap bitmap = (Bitmap)Image.FromFile(imagePath);
           
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            FastBitmap myFastBitmap = new FastBitmap(bitmap);
            myFastBitmap.LockBits();
            int width = myFastBitmap.Width, height = myFastBitmap.Height;
            FastBitmapBuilder myFastBitmapBuilder = new FastBitmapBuilder(
            width, height, fastFormat);
            myFastBitmapBuilder.LockBits();
            for (int i = 0; i < myFastBitmap.Flags; i++)
            {
                myFastBitmapBuilder[i / (myFastBitmap.Flags 
                / myFastBitmapBuilder.Flags)] = myFastBitmap[i];
            }


            bitmap = myFastBitmapBuilder;

            stopWatch.Stop();
            Console.WriteLine($"{stopWatch.ElapsedMilliseconds} ms");
            //Console writes 1102 ms

Here is an extension written using my FastBitmap class complete with comments.

C#

/// <summary>
        /// Inverts the specified <see cref="Bitmap"/>
        /// </summary>
        /// <param name="bitmap">Bitmap.</param>
        public static void Invert(this Bitmap bitmap)
        {
            //use the fastbitmap class to get pointer
            FastBitmap fast = new FastBitmap(bitmap);
            // lock the bits in place so we can manipulate image data
            fast.LockBits();
            for (int i = 0; i < fast.Flags; i++)
            {
                // set pixels of fast bitmap to negative value
                fast[i] = (byte)-fast[i];
            }
            fast.UnlockBits();
            // bitmap has negative pixels(inverted) 
        }

I appreciate that you are trying to address my points, but I am confused... how does this relate to your code that you posted above which still remains unchanged?

Put some effort into the article.

self taught, I'm not into the extra, which is why I'm sharing basic code as a tip/trick, not a full fledged article, do the work and fro

Perhaps When I release my FastBitmap class you would like to have a good read?

I was searching for something like this. Really compact without pInvoke

Thanks, I'm glad you find it helpful. I myself program in c# via Mono on Linux and pInvoke is not an option for me which is why I was looking for a workaround when I wrote this method.

No explanation dubious code.

Nothing dubious, just basic work with unsafe code. If you google working with unsafe code you will find many examples that use the same concept illustrated here. I would hope that you would reconsider the vote of 2.

The GUI recorded a vote of 2 when I intended 1. Feel happy.

The Gui?

Do you prefer widget ?

I'm assuming that you don't do much programming in .net? I've noticed that this is at least the second tip/trick that you've down voted because it is using the .net language. what is your preferred language, if you don't mind my asking?

I support all the languages that my customers require. C++ native, C++/CLI, C#, VB.

Your assumption is wrong and your insistence displaced.

I only ask because you mentioned on another tip/trick that it wasn't simple because it would require .net

displaced? how? it's basic communication. I don't understand, please explain?

Very simple conversion of bitmap to indexed bitmap

License

Comments and Discussions