Resizing a Bitmap used as watermark the result shows dark borders

Question

Problem:
I have a watermark that I want to print on an Image. The Image varies in size so sometimes the watermark is too big and sometimes it's too small. In order to fix this I calculate the size of the image and resize the watermark. However, after resizing the Image, black borders appear around its margins.

Code

I am on a Mac using .NET Core3.1 and I am using two NuGet packages that helps to draw images / bitmaps. One is System.Drawing.Common and the other one, because I am on macOS is, runtime.osx.10.10x64.CoreCompat.System.Drawing.

The code that I use to resize the watermark founded here:

Bitmap watermarkNew = new Bitmap(watermark, new Size(image.Width / 10 * 3, image.Height / 10 * 3));

I have to use / 10 * 3 because the Bitmap constructor doesn't accept floats values, so I cannot multiply by * 0.3.

Results:

watermark before            watermark after

Answer 1

To superimpose an Image on another, it's preferable to use an unscaled Image than generate a new Bitmap based on the desired size beforehand.

▶ The two Image are meant to blend, thus the scaling of one of the Images, in this case the Watermark Image, should be performed while the Image to scale is painted over the other with a SourceOver operation.
This way, the internal GDI+ (well, the GDI+ replica here) functions have means to calculate the blending procedure correctly.
This also prevents the copy to show imperfect semi-transparent pixels (similar to a dark halo) generated when a smaller Image is created using the new Bitmap() method.

▶ Also, we need to be sure that all operations are performed on a 32BitArgb Bitmaps.
It's better to create a 32BitArgb copy of the destination Image and draw the watermark on this copy. This can also ensure a better result. GDI+ function work better on this kind of Images.
Here, the CopyToArgb32() method takes care of this aspect, also applying the DPI resolution of the original Image to the copy.

▶ Furthermore, this produces a distorted Image (unless that's the expected result, that is):

Bitmap watermarkNew = new Bitmap(watermark, new Size(image.Width / 10 * 3, image.Height / 10 * 3));

The watermark Image dimensions should be resized calculating a scale factor that is a desired fraction (a percentage or a fixed measure) or the destination Image.

For example, to occupy a maximum size equals to one third of the destination Bitmap minimum dimension.
In other words, if the destination Bitmap size is 1500x600 px, the watermark Bitmap will be scaled proportionally to have a maximum Height of 200px:

float scale = (Math.Min(original.Width, original.Height) * .33f) / 
               Math.Min(watermark.Width, watermark.Height);
SizeF watermarkSize = new SizeF(watermark.Width * scale, watermark.Height * scale);

To further improve the blending, the Watermark could be made less opaque (or, more transparent, as you want to see it).
This can be simply achieved using as ColorMatrix as shown here:

How to apply a fade transition effect to Images

---

All combined in a class object that exposes a Watermark([Bitmap], [Bitmap], [Imageformat]) static method.

In the sample code, the Watermark is scaled to 1/3 of the maximum dimension of destination image and centered (just a generic placement, since the position of the watermark is not specified):

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

public class BitmapOperations
{
    public static Bitmap Watermark(Bitmap watermark, Bitmap original, ImageFormat format)
    {
        var units = GraphicsUnit.Pixel;
        float scale = (Math.Max(original.Width, original.Height) * .33f) / 
                       Math.Max(watermark.Width, watermark.Height);
        var watermarkSize = new SizeF(watermark.Width * scale, watermark.Height * scale);
        
        var watermarkBounds = CenterRectangleOnRectangle(
            new RectangleF(PointF.Empty, watermarkSize), original.GetBounds(ref units));
        var workImage = CopyToArgb32(original);
        // Using the SetOpacity() extension method described in the linked question
        // watermark = watermark.SetOpacity(.5f, 1.05f);

        using (var g = Graphics.FromImage(workImage)) {
            g.PixelOffsetMode = PixelOffsetMode.Half;
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
            g.DrawImage(watermark, watermarkBounds);

            return workImage;
        }
    }

    private static Bitmap CopyToArgb32(Bitmap source)
    {
        var bitmap = new Bitmap(source.Width, source.Height, PixelFormat.Format32bppArgb);
        bitmap.SetResolution(source.HorizontalResolution, source.VerticalResolution);
        using (var g = Graphics.FromImage(bitmap)) {
            g.DrawImage(source, new Rectangle(0, 0, bitmap.Width, bitmap.Height),
                                new Rectangle(0, 0, bitmap.Width, bitmap.Height), GraphicsUnit.Pixel);
            g.Flush();
        }
        return bitmap;
    }

    private static RectangleF CenterRectangleOnRectangle(RectangleF source, RectangleF destination)
    {
        source.Location = new PointF((destination.Width - source.Width) / 2,
                                     (destination.Height - source.Height) / 2);
        return source;
    }
}

Results:

Applying an opacity level of 50% and small correction in gamma: