Resize option to allow Max container size that does not upscale.

[nsmithdev]

We have a content management system with a specific container size.
Some images are wide and some are tall.
We would like to resize the photo to reduce size as far as need to fit inside the container.
Height and width both and do not upscale.

From my testing:
ResizeMode.Min does not shrink the image enough in one direction.
ResizeMode.Max will upscale smaller images.

I have written a test showing how ResizeMode.Min does not reduce the image enough

    [Fact]
    public void CalculateMinRectangleWhenSourceIsSmallerThanTarget2()
    {
        var sourceSize = new Size(2048, 1536);
        var target = new Size(1920, 1080);

        (Size size, Rectangle rectangle) = ResizeHelper.CalculateTargetLocationAndBounds(
            sourceSize,
            new ResizeOptions
            {
                Mode = ResizeMode.Min,
                Size = target
            });
        Assert.Equal(1080, size.Height);
        Assert.True(target.Width >= size.Width);
        Assert.True(target.Height >= size.Height);
    }

Result: Assert.Equal() Failure: Values differ
Expected: 1080
Actual: 1440

Am I missing something here as this seems like it would be a common use case of reduce an image proportionally in either direction so long as it's smaller than the destination in both direction and don't upscale.

I believe Max would work for me if it did not upscale.

I'm sure I can add something to only resize if photo is larger in one of the two direction to prevent upscale but wanted to check I wasn't missing something since it seems like it would be a common use case.

[JimBobSquarePants]

I can see where confusion lies...

Here's the description for Min and it's admittedly not written well at all and should be rewritten.

Resizes the image until the shortest side reaches the set given dimension.
Upscaling is disabled in this mode and the original image will be returned
if attempted.

Really it should be something like this:

Resizes the image while preserving its aspect ratio, ensuring that at least one dimension meets or exceeds the target size. The decision is based on the difference between the source and target dimensions. The dimension with the smaller difference is scaled to match its target, while the other is adjusted proportionally. If the image is already smaller than the target size in both dimensions, it is returned unchanged, as upscaling is not allowed.

So essentially, it's finding the dimension with the smallest delta and scaling using that as the starting point.

Am I missing something here as this seems like it would be a common use case of reduce an image proportionally in either direction so long as it's smaller than the destination in both direction and don't upscale.

Given that this is the only library that offers precalculated options such as I would disagree that this requirement should be something already existing. Max is the closest and I don't think it's unreasonable for consumers to sanitize their input prior to calling this library functions.

[nsmithdev]

Thanks for the quick answer, your awesome.

I'm was trying to shrink a folder of images down to less than a reasonable size by reducing dimensions and applying compression.
It was late and think I was just confused that Max was upscaling when I noticed some file sizes increase.

This was enough to make Max do what I want and prevent upscaling.

Helper

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;

public static class ImageSharpHelpers
{
    public static IImageProcessingContext ResizeDownTo(this IImageProcessingContext context, int maxWidth, int maxHeight)
    {
        var currentSize = context.GetCurrentSize();
        if (currentSize.Width > maxWidth || currentSize.Height > maxHeight)
        {
            context.Resize(new ResizeOptions()
            {
                Mode = ResizeMode.Max,
                Size = new Size(maxWidth, maxHeight),
            });
        }
        return context;
    }
}

Usage

image.Mutate(x => x.ResizeDownTo(1920, 1024));

[JimBobSquarePants]

Yeah, that looks good. If the encoded image file size is bigger have a look at the options on the encoder. I try to ensure that inbound/outbound options are cariied through but maybe something has been missed or not supported yet.