How to set the bits/pixels to a WriteableBitmap (with BlackWhite format (1bpp))

I am trying to create a binary image in C#/WPF using the WriteableBitmap class, with the BlackWhite Format which is 1 bit per pixel.

However, it seems the my image is very distorted when finished. Using different formats (such as brg32) works just fine. The pixel data is stored in a BitArray. The images vary from 1000x1000 to 3000x3000 pixels.

Here is the code I am current using:

unsafe
            {
                int colorOffset = 0;
                int pixelOffset = 0;
                byte color = 0;
                int pBackBuffer = (int)_image.BackBuffer;

                for (int y = 0; y < mapData.Height; y++)
                {
                    for (int x = 0; x < mapData.Width; x++)
                    {

                        if (mapData.Data[y * mapData.Height + x])
                        {
                            //Set the pixel to white
                            color += 1;
                        }

                        //Shift the pixel position by 1
                        color = (byte)(color << 1);

                        //If 8 pixels have been written, write it to the backbuffer
                        if (++colorOffset == 8)
                        {
                            pixelOffset = ((y * mapData.Height) + x) / 8;
                开发者_C百科            *(byte*)(pBackBuffer + pixelOffset) = color;
                            color = 0;
                            colorOffset = 0;
                        }

                    }
                }
                //Update the image
                _image.AddDirtyRect(new Int32Rect(0, 0, mapData.Width, mapData.Height));
            }

As you can see, I am writing 8 pixels / bits , and then copying it to the back buffer. Perhaps someone who has a bit more knowledge in this topic could help. I've also tried directly copying the BitArray to a byte array, then copy the byte array to the backbuffer (and using the WritePixels function as well), both of which have not helped.

Regards, Dan

It seems like you are not using BackBufferStride property to compute address of the next line of pixels. Also note that you are missing some pixels if map width is not a multiple of 8. I didn't test the code, but i would have written it like this:

unsafe
{
    int colorOffset = 0;
    int pixelOffset = 0;
    byte color = 0;
    byte* pBackBuffer = (byte*)_image.BackBuffer;
    for(int y = 0; y < mapData.Height; y++)
    {
        // get a pointer to first pixel in a line y
        byte* pixLine = pBackBuffer;
        for(int x = 0; x < mapData.Width; x++)
        {

            // fix #1: offset = y * width + x, not y * height + x
            var mapOffset = y * mapData.Width + x;

            if (mapData.Data[mapOffset])
            {
                //Set the pixel to white
                color += 1;
            }

            //Shift the pixel position by 1
            color = (byte)(color << 1);

            //If 8 pixels have been written, write it to the backbuffer
            if(++colorOffset == 8)
            {
                *pixLine++ = color;
                color = 0;
                colorOffset = 0;
            }

        }
        // fix #2: copy any pixels left
        if(colorOffset != 0)
        {
            *pixLine++ = color;
            colorOffset = 0;
            color = 0;
        }

        // fix #3: next line offset = previous line + stride, they are aligned
        pBackBuffer += _image.BackBufferStride;
    }
    //Update the image
    _image.AddDirtyRect(new Int32Rect(0, 0, mapData.Width, mapData.Height));
}