Scaling a System.Drawing.Bitmap to a Given Size While Maintaining Aspect Ratio

Scaling a System.Drawing.Bitmap to a given size while maintaining aspect ratio

Target parameters:

float width = 1024;
float height = 768;
var brush = new SolidBrush(Color.Black);

Your original file:

var image = new Bitmap(file);

Target sizing (scale factor):

float scale = Math.Min(width / image.Width, height / image.Height);

The resize including brushing canvas first:

var bmp = new Bitmap((int)width, (int)height);
var graph = Graphics.FromImage(bmp);

// uncomment for higher quality output
//graph.InterpolationMode = InterpolationMode.High;
//graph.CompositingQuality = CompositingQuality.HighQuality;
//graph.SmoothingMode = SmoothingMode.AntiAlias;

var scaleWidth = (int)(image.Width * scale);
var scaleHeight = (int)(image.Height * scale);

graph.FillRectangle(brush, new RectangleF(0, 0, width, height));
graph.DrawImage(image, ((int)width - scaleWidth)/2, ((int)height - scaleHeight)/2, scaleWidth, scaleHeight);

And don't forget to do a bmp.Save(filename) to save the resulting file.

c# Image resizing to different size while preserving aspect ratio

I found out how to resize AND pad the image by learning from this this CodeProject Article.

static Image FixedSize(Image imgPhoto, int Width, int Height)
    {
        int sourceWidth = imgPhoto.Width;
        int sourceHeight = imgPhoto.Height;
        int sourceX = 0;
        int sourceY = 0;
        int destX = 0;
        int destY = 0;

        float nPercent = 0;
        float nPercentW = 0;
        float nPercentH = 0;

        nPercentW = ((float)Width / (float)sourceWidth);
        nPercentH = ((float)Height / (float)sourceHeight);
        if (nPercentH < nPercentW)
        {
            nPercent = nPercentH;
            destX = System.Convert.ToInt16((Width -
                          (sourceWidth * nPercent)) / 2);
        }
        else
        {
            nPercent = nPercentW;
            destY = System.Convert.ToInt16((Height -
                          (sourceHeight * nPercent)) / 2);
        }

        int destWidth = (int)(sourceWidth * nPercent);
        int destHeight = (int)(sourceHeight * nPercent);

        Bitmap bmPhoto = new Bitmap(Width, Height,
                          PixelFormat.Format24bppRgb);
        bmPhoto.SetResolution(imgPhoto.HorizontalResolution,
                         imgPhoto.VerticalResolution);

        Graphics grPhoto = Graphics.FromImage(bmPhoto);
        grPhoto.Clear(Color.Red);
        grPhoto.InterpolationMode =
                InterpolationMode.HighQualityBicubic;

        grPhoto.DrawImage(imgPhoto,
            new Rectangle(destX, destY, destWidth, destHeight),
            new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight),
            GraphicsUnit.Pixel);

        grPhoto.Dispose();
        return bmPhoto;
    }

Resizing a Bitmap used as watermark the result shows dark borders

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:

Image Getting Stretched when trying to Resize It keeping the aspect Ratio

Try this, its a bit neater

public static Bitmap ResizeImage(Bitmap source, Size size)
{
   var scale = Math.Min(size.Width / (double)source.Width, size.Height / (double)source.Height);   
   var bmp = new Bitmap((int)(source.Width * scale), (int)(source.Height * scale));

   using (var graph = Graphics.FromImage(bmp))
   {
      graph.InterpolationMode = InterpolationMode.High;
      graph.CompositingQuality = CompositingQuality.HighQuality;
      graph.SmoothingMode = SmoothingMode.AntiAlias;
      graph.DrawImage(source, 0, 0, bmp.Width, bmp.Height);
   }
   return bmp;
}

How to set a width and height to a bitmap in c#?

Bitmap original = (Bitmap)Image.FromFile("DSC_0002.jpg");
Bitmap resized = new Bitmap(original,new Size(newWidth,newHeight));

Scaled Bitmap maintaining aspect ratio

What about this:

Bitmap background = Bitmap.createBitmap((int)width, (int)height, Config.ARGB_8888);

float originalWidth = originalImage.getWidth(); 
float originalHeight = originalImage.getHeight();

Canvas canvas = new Canvas(background);

float scale = width / originalWidth;

float xTranslation = 0.0f;
float yTranslation = (height - originalHeight * scale) / 2.0f;

Matrix transformation = new Matrix();
transformation.postTranslate(xTranslation, yTranslation);
transformation.preScale(scale, scale);

Paint paint = new Paint();
paint.setFilterBitmap(true);

canvas.drawBitmap(originalImage, transformation, paint);

return background;

I added a paint to filter the scaled bitmap.

Resize bitmap image

Does your "surface" visual have scaling capability? You can wrap it in a Viewbox if not, then render the Viewbox at the size you want.

When you call Measure and Arrange on the surface, you should provide the size you want the bitmap to be.

To use the Viewbox, change your code to something like the following:

Viewbox viewbox = new Viewbox();
Size desiredSize = new Size(surface.Width / 2, surface.Height / 2);

viewbox.Child = surface;
viewbox.Measure(desiredSize);
viewbox.Arrange(new Rect(desiredSize));

RenderTargetBitmap renderBitmap =
    new RenderTargetBitmap(
    (int)desiredSize.Width,
    (int)desiredSize.Height, 96d, 96d,
    PixelFormats.Default);
renderBitmap.Render(viewbox);

Resize Image while maintaining aspect ratio

Image thumb = image.GetThumbnailImage(image.Width / 2, image.Height / 2, null, IntPtr.Zero);
image.Dispose();

---

Related Topics