C# WPF Combining multiple bitmaps into one

Question

Hello I'm working on a WPF program to automate the process of producing cards (I feed it information from a database, it spits out image files of the correct dimensions).

These cards are made up of 3 effective "layers" placed on top of each other and should produce an output like so

(if I need to remove it I will, since I just grabbed an image with the right aspect ratio).

Now I can get the separate "layers" as their own bitmaps with something like

//Get the filepath and store it in a variable named 'FilePath' before this
BitmapImage image =  new BitmapImage();
image.UriSource = (Uri)FilePath;

(I know that code isn't right but you get the idea).

So the question is, how do I add these three bitmaps together into a single bitmap that can then be saved as say a .png or such.

I know WinForms has a lot more options built in for image and bitmap manipulation but I am doing this in WPF.

I was thinking of doing this with byte arrays and using loops to copy values from one to the other but any better suggestions are highly appreciated.

Answer 1

I think it's important to understand here what WinForms and WPF actually are.

WPF did not "replace" all the stuff in WinForms. WinForms is essentially a wrapper to the underlying Windows GDI API, which is itself still very much a current technology and likely to remain so in the foreseeable future.

WPF replaces the rendering of GUI elements with an engine based on DirectX. In order to do this it has to provide its own image classes, but this is solely for the purpose of display within the hardware-accelerated DirectX environment.

This is an important distinction: WPF is not, in-and-of itself, a part of the Windows operating system. It uses DirectX for rendering, but DirectX itself is designed for interfacing to graphics hardware and not for direct image manipulation (with some rare exceptions like GPU processing). The GDI, however, is still very much a part of windows and was specifically designed for this kind of thing, all the way back to the days of software rendering.

So in other words, unless you have a very specific requirement that involves hardware accelerated display you may as well use the GDI. WPF and WinForms can co-exist alongside each other just fine because they do completely different things. Just because one of the things WinForms happens to do is expose an older rendering technology that you don't want to use yourself doesn't mean that WinForms as a whole is obsolete.

UPDATE: to use GDI functions you'll need to add a reference to System.Drawing; normally this is done for you when you create a windows project but if you've created a console application etc then you'll need to do it manually. The Graphics class provides many functions for rendering, but from what you've described this will probably cover most of what you're trying to do:

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

namespace yournamespace
{
    class Program
    {
        private static void Main(string[] args)
        {
            // load an image
            var source = new Bitmap("source.png");

            // create a target image to draw into
            var target = new Bitmap(1000, 1000, PixelFormat.Format32bppRgb);

            // get a context
            using (var graphics = Graphics.FromImage(target))
            {
                // draw an image into it, scaled to a different size
                graphics.DrawImage(source, new Rectangle(250, 250, 500, 500));

                // draw primitives
                using (var pen = new Pen(Brushes.Blue, 10))
                    graphics.DrawEllipse(pen, 100, 100, 800, 800);
            }

            // save the target to a file
            target.Save("target.png", ImageFormat.Png);
        }
    }
}