CODEWITHSUNDEEP
c#wpfgraphicsbitmap
Liglo App
Liglo App

Reputation: 3819

C# / WPF Bitmap remains white after setting some values (with LockBits)

Using MS Visual Studio 2013, having this code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices; 
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Drawing;
using System.Drawing.Imaging;

namespace SplashNS
{    

    public partial class DocumentWindow : Window
    {
        public SplashFile File;

        [DllImport("gdi32")]
        static extern int DeleteObject(IntPtr o);

        private BitmapSource _loadBitmap(System.Drawing.Bitmap source)
        {
            IntPtr ip = source.GetHbitmap();
            BitmapSource bs = null;
            try
            {
                bs = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(ip,
                   IntPtr.Zero, Int32Rect.Empty,
                   System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
            }
            finally
            {
                DeleteObject(ip);
            }

            return bs;
        }

        public DocumentWindow()
        {
            InitializeComponent();
            Bitmap canvas = new Bitmap(663, 356);
            BitmapData bmd = canvas.LockBits(new System.Drawing.Rectangle(0, 0, canvas.Width, canvas.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, canvas.PixelFormat);
            int PixelSize = 4;

            unsafe
            {
                for (int y = 0; y < canvas.Height; y++)
                {
                    byte* row = (byte*)bmd.Scan0 + (y * bmd.Stride);
                    for (int x = 0; x < canvas.Width; x++)
                    {
                        row[x * PixelSize] = 255;    
                    }
                }
            }
            canvas.UnlockBits(bmd);          
            SplashCanvas.Source = this._loadBitmap(canvas);
        }
    }
}

doesn't work. It generates a white bitmap instead of one with all blue pixels. No errors are displayed.

I guess, it must be a noob issue, but I am a beginner. I suppose it must be something with the pixel format, but I can also be wrong with that...

Upvotes: 2

Views: 321

Answers (2)

dbc
dbc

Reputation: 116710

You seem to be creating an old-style System.Drawing.Bitmap then converting it to WPF, however WPF has a pretty complete set of utilities for creating bitmaps from scratch using WritableBitmap. See this article for an overview: Foundations: Bitmaps and Pixel Bits.

For instance, here's code that creates a solid bitmap of a given size and color:

public static class BitmapHelper
{
    public unsafe static BitmapSource CreateSolidBitmap(int width, int height, double dpiX, double dpiY, Color color)
    {
        var bitmap = new WriteableBitmap(width, height, dpiX, dpiY, PixelFormats.Pbgra32, null);
        var format = bitmap.Format;
        int blueIndex, greenIndex, redIndex, alphaIndex;
        int bitsPerPixel, bytesPerPixel;
        if (!TryParsePixelFormat(format, out bitsPerPixel, out bytesPerPixel, out blueIndex, out greenIndex, out redIndex, out alphaIndex))
            return null;
        var byteWidth = bytesPerPixel * width;
        bitmap.Lock();
        try
        {
            var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();
            for (int iRow = 0; iRow < height; iRow++)
            {
                var row = backBuffer + (iRow * bitmap.BackBufferStride);
                for (byte* pixel = row, endRow = row + byteWidth; pixel < endRow; pixel += bytesPerPixel)
                {
                    pixel[blueIndex] = color.B;
                    pixel[greenIndex] = color.G;
                    pixel[redIndex] = color.R;
                    if (alphaIndex >= 0)
                        pixel[alphaIndex] = color.A;
                }
            }
            bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));
        }
        finally
        {
            bitmap.Unlock();
        }
        return bitmap;
    }

    static int BlueIndex = 0;
    static int GreenIndex = 1;
    static int RedIndex = 2;
    static int AlphaIndex = 3;

    private static bool TryFindColorIndex(PixelFormatChannelMask mask, out int index)
    {
        var maskList = mask.Mask;
        for (int i = 0, count = maskList.Count; i < count; i++)
        {
            if (maskList[i] == 255)
            {
                index = i;
                return true;
            }
        }
        index = -1;
        return false;
    }

    static bool TryParsePixelFormat(PixelFormat format, out int bitsPerPixel, out int bytesPerPixel, out int blueIndex, out int greenIndex, out int redIndex, out int alphaIndex)
    {
        // Currently only implemented for non-indexed formats with 3 or 4 bytes
        // per color.
        bitsPerPixel = format.BitsPerPixel;
        if ((bitsPerPixel % 8) != 0)
        {
            bytesPerPixel = blueIndex = greenIndex = redIndex = alphaIndex = -1;
            return false;
        }

        bytesPerPixel = bitsPerPixel / 8;

        var masks = format.Masks;
        int maskCount = masks.Count;

        if (maskCount == 3 || maskCount == 4)
        {
            var blueMask = masks[BlueIndex];
            var greenMask = masks[GreenIndex];
            var redMask = masks[RedIndex];

            if (!TryFindColorIndex(blueMask, out blueIndex)
                || !TryFindColorIndex(greenMask, out greenIndex)
                || !TryFindColorIndex(redMask, out redIndex))
            {
                bytesPerPixel = blueIndex = greenIndex = redIndex = alphaIndex = -1;
                return false;
            }

            if (maskCount == 3)
            {
                alphaIndex = -1;
            }
            else
            {
                if (!TryFindColorIndex(masks[AlphaIndex], out alphaIndex))
                    alphaIndex = -1;
            }

            return true;
        }

        bytesPerPixel = blueIndex = greenIndex = redIndex = alphaIndex = -1;
        return false;
    }
}

Since this is a static method it doesn't know the DPI for your running application, however you can get it inside your main window (or any other window) like this:

    PresentationSource source = PresentationSource.FromVisual(this);

    double dpiX = 96.0, dpiY = 96.0;
    if (source != null)
    {
        dpiX = 96.0 * source.CompositionTarget.TransformToDevice.M11;
        dpiY = 96.0 * source.CompositionTarget.TransformToDevice.M22;
    }

96 seems to get used by convention when this is not available.

Upvotes: 2

MartinStettner
MartinStettner

Reputation: 29164

I guess the problem is that you specify ImageLockMode.ReadOnly in the flags parameter of you LockBits call.

Try using ImageLockMode.ReadWrite (or ImageLockMode.WriteOnly) instead.

Upvotes: 0

Related Questions