Upgrading from 3.0.2 to 3.1.5 causes draws to be at 0.0.

[ChadJessup]

I'm having a hard time hunting down where the issue is, it could be my code somewhere, but I've spent a good chunk of time trying to hunt this issue down.

If you look at the first image, this is multiple assets draw on top of others - this is for 3.0.2.

After a 3.1.5 upgrade and no other changes, various components are now getting written at 0.0.

My guess is that the minor version bump might have introduced new DrawImage overrides, and I'm now calling different code on accident since I didn't always use named parameters when calling into ImageSharp.

I should note that this first showed up when upgrading from 3.0.2 to 3.1.0 - but due to how input validation changed I had to make code changes to compile, but with 3.1.3 I don't have to do any code changes at all from 3.0.2.

   public void BlitSurfaceToSurface(
       Image<Rgba32> src,
       SurfaceType dst,
       Point dstPoint,
       VO_BLT bltFlags = VO_BLT.SRCTRANSPARENCY,
       bool debug = false)
   {
       var dstSurface = this.Surfaces.SurfaceByTypes[dst];

       Rectangle dstRectangle = new()
       {
           Height = src.Height,
           Width = src.Width,
           X = dstPoint.X,
           Y = dstPoint.Y,
       };

       dstSurface.Image.Mutate(ctx =>
       {
           ctx.DrawImage(
               src,
               dstPoint,
               dstRectangle,
               colorBlending: PixelColorBlendingMode.Normal,
               //                alphaComposition: PixelAlphaCompositionMode.Dest,
               opacity: 1.0f);
       });
   }

On 3.1.5 Visual Studio is strongly implying I'm calling into this DrawImage override:

    /// <summary>
    /// Draws the given image together with the currently processing image by blending their pixels.
    /// </summary>
    /// <param name="source">The current image processing context.</param>
    /// <param name="foreground">The image to draw on the currently processing image.</param>
    /// <param name="backgroundLocation">The location on the currently processing image at which to draw.</param>
    /// <param name="foregroundRectangle">The rectangle structure that specifies the portion of the image to draw.</param>
    /// <param name="colorBlending">The color blending to apply.</param>
    /// <param name="opacity">The opacity of the image to draw. Must be between 0 and 1.</param>
    /// <returns>The <see cref="IImageProcessingContext"/>.</returns>
    public static IImageProcessingContext DrawImage(
        this IImageProcessingContext source,
        Image foreground,
        Point backgroundLocation,
        Rectangle foregroundRectangle,
        PixelColorBlendingMode colorBlending,
        float opacity)
        => DrawImage(source, foreground, backgroundLocation, foregroundRectangle, colorBlending, source.GetGraphicsOptions().AlphaCompositionMode, opacity);

In 3.0.2 it looks like I'm calling the same thing (below) - I know in 3.1.0, I had to explicitly try to hit specific overrides because of the validation changes, but I'm trying to minimize changes for this discussion.

    /// <summary>
    /// Draws the given image together with the currently processing image by blending their pixels.
    /// </summary>
    /// <param name="source">The current image processing context.</param>
    /// <param name="foreground">The image to draw on the currently processing image.</param>
    /// <param name="backgroundLocation">The location on the currently processing image at which to draw.</param>
    /// <param name="foregroundRectangle">The rectangle structure that specifies the portion of the image to draw.</param>
    /// <param name="colorBlending">The color blending to apply.</param>
    /// <param name="opacity">The opacity of the image to draw. Must be between 0 and 1.</param>
    /// <returns>The <see cref="IImageProcessingContext"/>.</returns>
    public static IImageProcessingContext DrawImage(
        this IImageProcessingContext source,
        Image foreground,
        Point backgroundLocation,
        Rectangle foregroundRectangle,
        PixelColorBlendingMode colorBlending,
        float opacity)
        => DrawImage(source, foreground, backgroundLocation, foregroundRectangle, colorBlending, source.GetGraphicsOptions().AlphaCompositionMode, opacity);

Digging through the releases, I have a gut feeling I'm being caught up in one of the DrawImage changes?

#2474
#2673

Any help would be appreciated, this seems like a pretty common code path to be hit, so I'm fairly certain it's an issue on my end, but not sure what's going on.

Thanks!

[ChadJessup]

For completeness, 3.1.0 gives this exception in the same line of code, but that exception is gone after 3.1.3...

[JimBobSquarePants]

Sorry @ChadJessup I really meant to look at this sooner.

There was a lot of confusion plus some broken behavior prior to v3.1.1 which were causing issues. I believe we have solved them all though now.

In your code example you are using the dstPoint parameter to populate both the location on the background at which to draw the foreground and the location on the foreground rectangle at which to sample the foreground.

Rectangle dstRectangle = new()
{
    Height = src.Height,
    Width = src.Width,
    X = dstPoint.X,
    Y = dstPoint.Y,
};

dstSurface.Image.Mutate(ctx =>
{
    ctx.DrawImage(
        src,
        dstPoint,
        dstRectangle,
        colorBlending: PixelColorBlendingMode.Normal,
        //                alphaComposition: PixelAlphaCompositionMode.Dest,
        opacity: 1.0f);
});

I can demonstrate using the following image and code how the API is designed to work.

using Image<Rgba32> foreground = Image.Load<Rgba32>(@"D:\SixLabors\ImageSharp\tests\Images\Input\Png\issues\issue_2447.png");
using Image<Rgba32> background = new Image<Rgba32>(100, 100, Color.HotPink);

//                                                 // Draw here             // Draw this
background.Mutate(c => c.DrawImage(foreground, new Point(30, 30), new Rectangle(32, 32, 32, 32), 1F));

background.Save(@"C:\Users\james\Downloads\2186-draw-image.png");

Does this make sense?