Search code examples
c#.netimagepicturebox

C# unable to display RAW16 grayscale image with correct color mapping

Modifying the code provided in this link:

Original code

I wrote this:

    private void btnLoad_Click(object sender, EventArgs e)
    {
        if (System.IO.File.Exists(txtPicture.Text))
        {
            byte[] _data = System.IO.File.ReadAllBytes(txtPicture.Text);

            var _rgbData = Convert16BitGrayScaleToRgb16(_data, 160, 120);
            var _bmp = CreateBitmapFromBytes(_rgbData, 160, 120);

            pbFrame.Image = _bmp;
        }
    }

    private static void Convert16bitGSToRGB(UInt16 color, out byte red, out byte green, out byte blue)
    {
        red = (byte)(color & 0x31);
        green = (byte)((color & 0x7E0) >> 5);
        blue = (byte)((color & 0xF800) >> 11);
    }

    private static byte[] Convert16BitGrayScaleToRgb48(byte[] inBuffer, int width, int height)
    {
        int inBytesPerPixel = 2;
        int outBytesPerPixel = 6;

        byte[] outBuffer = new byte[width * height * outBytesPerPixel];
        int inStride = width * inBytesPerPixel;
        int outStride = width * outBytesPerPixel;

        // Step through the image by row
        for (int y = 0; y < height; y++)
        {
            // Step through the image by column
            for (int x = 0; x < width; x++)
            {
                // Get inbuffer index and outbuffer index
                int inIndex = (y * inStride) + (x * inBytesPerPixel);
                int outIndex = (y * outStride) + (x * outBytesPerPixel);

                byte hibyte = inBuffer[inIndex + 1];
                byte lobyte = inBuffer[inIndex];

                //R
                outBuffer[outIndex] = lobyte;
                outBuffer[outIndex + 1] = hibyte;

                //G
                outBuffer[outIndex + 2] = lobyte;
                outBuffer[outIndex + 3] = hibyte;

                //B
                outBuffer[outIndex + 4] = lobyte;
                outBuffer[outIndex + 5] = hibyte;
            }
        }
        return outBuffer;
    }

    private static byte[] Convert16BitGrayScaleToRgb16(byte[] inBuffer, int width, int height)
    {
        int inBytesPerPixel = 2;
        int outBytesPerPixel = 2;

        byte[] outBuffer = new byte[width * height * outBytesPerPixel];
        int inStride = width * inBytesPerPixel;
        int outStride = width * outBytesPerPixel;

        // Step through the image by row
        for (int y = 0; y < height; y++)
        {
            // Step through the image by column
            for (int x = 0; x < width; x++)
            {
                // Get inbuffer index and outbuffer index
                int inIndex = (y * inStride) + (x * inBytesPerPixel);
                int outIndex = (y * outStride) + (x * outBytesPerPixel);

                byte hibyte = inBuffer[inIndex];
                byte lobyte = inBuffer[inIndex+1];

                outBuffer[outIndex] = lobyte;
                outBuffer[outIndex+1] = hibyte;
            }
        }

        return outBuffer;
    }

    private static byte[] Convert16BitGrayScaleToRgb24(byte[] inBuffer, int width, int height)
    {
        int inBytesPerPixel = 2;
        int outBytesPerPixel = 3;

        byte[] outBuffer = new byte[width * height * outBytesPerPixel];
        int inStride = width * inBytesPerPixel;
        int outStride = width * outBytesPerPixel;

        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                int inIndex = (y * inStride) + (x * inBytesPerPixel);
                int outIndex = (y * outStride) + (x * outBytesPerPixel);

                byte hibyte = inBuffer[inIndex];
                byte lobyte = inBuffer[inIndex + 1];

                byte r, g, b;

                UInt16 color = (UInt16)(hibyte << 8 | lobyte);

                Convert16bitGSToRGB(color, out r, out g, out b);

                outBuffer[outIndex] = r;
                outBuffer[outIndex + 1] = g;
                outBuffer[outIndex + 2] = b;
            }
        }

        return outBuffer;
    }

    private static Bitmap CreateBitmapFromBytes(byte[] pixelValues, int width, int height)
    {
        //Create an image that will hold the image data

        Bitmap bmp = new Bitmap(width, height, PixelFormat.Format16bppRgb565);

        //Get a reference to the images pixel data
        Rectangle dimension = new Rectangle(0, 0, bmp.Width, bmp.Height);
        BitmapData picData = bmp.LockBits(dimension, ImageLockMode.ReadWrite, bmp.PixelFormat);
        IntPtr pixelStartAddress = picData.Scan0;

        //Copy the pixel data into the bitmap structure
        Marshal.Copy(pixelValues, 0, pixelStartAddress, pixelValues.Length);

        bmp.UnlockBits(picData);
        return bmp;
    }

But still the result of the conversion is not satisfying/correct. This's the picture I should get:

Original picture

Converting the file linked here:

Example RAW16 picture file

This's the result using Convert16BitGrayScaleToRgb48:

enter image description here

This's the result using Convert16BitGrayScaleToRgb16:

GrayScaleToRgb16

This's the result using Convert16BitGrayScaleToRgb24:

GrayScaleToRgb24

It's quite clear that the color remapping is wrong but I cant understand where the problem is.

Additionally I also found that picturebox didn't show exactly what it stores. The second image from the top (Convert16BitGrayScaleToRgb48 result) is what the picturebox shows while the following picture is what I obtain if I save the image shown in PNG format:

Image saved

I tought RAW16 grayscale should mean 2 bytes containing either a 16 bit gray value or an RGB gray value encoded on a 565 or 555 map. But none of those hypotesis seems to match the real thing.

Someone has an hint on how to convert the value provided in the source file to obtain a picture like the first one (obtained from the same source using ImageJ)?

Solution

  • I found a possibile hint using GIMP. If I load the original file trough this app (changing extension in .data and/or forcing to load it as RAW) and setting it as a 160x120 16bpp BigEndian I got a nearly black frame (!), but if I change levels compressing the range around the only small peak present (around 12,0 black - 13,0 white) the image result correct. Changing endianism is pretty straightforward compressing the dynamic range a little less but I'm working on it.

    The first lesson learned in this experience is "Don't trust your eyes" :-).

    The final result of my efforts are these three methods:

    public static void GetMinMax(byte[] data, out UInt16 min, out UInt16 max, bool big_endian = true)
{
    if (big_endian)
        min = max = (UInt16)((data[0] << 8) | data[1]);
    else
        min = max = (UInt16)((data[1] << 8) | data[0]);

    for (int i = 0; i < (data.Length - 1); i += 2)
    {
        UInt16 _value;

        if (big_endian)
            _value = (UInt16)((data[i] << 8) | data[i + 1]);
        else
            _value = (UInt16)((data[i + 1] << 8) | data[i]);

        if (_value < min)
            min = _value;

        if (_value > max)
            max = _value;
    }
}

public static void CompressRange(byte MSB, byte LSB, UInt16 min, UInt16 max, out byte color, Polarity polarity)
{
    UInt16 _value = (UInt16)((MSB << 8) | LSB);

    _value -= min;

    switch (polarity)
    {
        case Polarity.BlackHot:
            _value = (UInt16)((_value * 255) / (max - min));
            _value = (UInt16)(255 - _value);
            break;

        default:
        case Polarity.WhiteHot:
            _value = (UInt16)((_value * 255) / (max - min));
            break;
    }

    color = (byte)(_value & 0xff);
}

public static byte[] Convert16BitGrayScaleToRgb24(byte[] inBuffer, int width, int height, UInt16 min, UInt16 max, bool big_endian = true, Polarity polarity = Polarity.WhiteHot)
{
    int inBytesPerPixel = 2;
    int outBytesPerPixel = 3;

    byte[] outBuffer = new byte[width * height * outBytesPerPixel];
    int inStride = width * inBytesPerPixel;
    int outStride = width * outBytesPerPixel;

    for (int y = 0; y < height; y++)
    {
        for (int x = 0; x < width; x++)
        {
            int inIndex = (y * inStride) + (x * inBytesPerPixel);
            int outIndex = (y * outStride) + (x * outBytesPerPixel);

            byte hibyte;
            byte lobyte;

            if (big_endian)
            {
                hibyte = inBuffer[inIndex];
                lobyte = inBuffer[inIndex + 1];
            }
            else
            {
                hibyte = inBuffer[inIndex + 1];
                lobyte = inBuffer[inIndex];
            }

            byte gray;

            CompressRange(hibyte, lobyte, min, max, out gray, polarity);

            outBuffer[outIndex] = gray;
            outBuffer[outIndex + 1] = gray;
            outBuffer[outIndex + 2] = gray;
        }
    }

    return outBuffer;
}

    These allows to load the file attached to the original question and display it on a standard WindowsForm PictureBox. Using 48bpp format will result in a degraded image on some graphic cards (at least on mine). BTW GetMinMax calculate min max value on the current frame regardless of the history of the environment. This means that if you are going to use this functions to display a picture sequence (as I am) a strong variation of average temperature in the FOV will drive the overall image to a different exposure resulting in loosing some details of the picture. In such cases I suggest to calculate min-max over the current frame but NON to use it in Convert16BitGrayScaleToRgb24 using instead a moving average for both values.