Keyvan Nayyeri

[Update 3: I've updated my code to use Windows Imaging Component for image resizing to avoid the issues with ASP.NET.]

[Update 2: Nathanael Jones has a fantastic comment to share his expertise in image resizing and the issues discussed in other comments about System.Drawing.]

[Update 1: As some people pointed out in comments, the use of the third approach in a Windows or ASP.NET service may cause problems as is documented on MSDN, however, you should rethink your implementation if you're performing a resize scneario inside a service. There should be better alternatives for doing that.]

To be fair, I can’t call it very high quality because it’s just high quality and there isn’t anything higher than high, however, as I’ll discuss later, since this has a higher quality than the existing techniques for high quality resizing, I’d call it very high quality to help search engines.

I’m the type of the lazy programmer who knows software engineering and doesn’t waste time reinventing the wheel, so I usually try to find solutions to existing classic problems when I’m writing code. Working on Hawraman, the engine powering Keyvan.TV, I needed to resize the poster image of videos dynamically to display them to users both on Keyvan.TV and on any third party site that uses the embedment code. Apparently, I had to create a controller that serves for dynamically resizing my images on fly and rendering them in the output. Looking for the existing solutions, I copy/pasted 4-5 different codes available on the internet, but none of them gave me a satisfactory result, so I had to invest more and write an improved code. Although I usually don’t publish posts that are already done by others, I guess this time I have to publish this one and share the code to help others when they’re searching for the solution. Yes, I know, it’s like a 1980’s blog post, but I’m an old guy!

Here I implement my image resizing techniques in an ASP.NET MVC controller, however, the logic is the same for applying this technique to other types of applications including ASP.NET Web Forms or desktop applications. I have to point that the first two approaches discussed below are discussed in more details by Gunnar Peipman, Mike Borozdin, and many others (with some minor modifications), however, these approaches don’t provide the high quality that you may need for many scenarios, or at least, they couldn’t serve for my purposes.

Setup

I implement my resizing techniques in different action methods in an ASP.NET MVC controller. These action methods receive the width and height of the destination image as their parameters. I can set up my routing to handle this controller, called ImageResizeController.

public static void RegisterRoutes(RouteCollection routes)
{
    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

    routes.MapRoute(
        "ImageResizer",
        "imageresize/{action}/{width}/{height}",
        new { controller = "ImageResize", action = "Index", width = 400, height = 225 }
        );

    routes.MapRoute(
        "Default", // Route name
        "{controller}/{action}/{id}", // URL with parameters
        new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
    );
}

The original image is a big image of my ugly and funny face that I recorded for the Pilot episode on Keyvan.TV as you see below (the original image is 1920×1080 pixels that you can find in the source code sample package). Later on, I try to resize this image to 400×225 pixels.

Naïve Quality

The very naïve approach to image resizing is to use the GetThumbnailImage function of System.Drawing.Image class.

public ActionResult Naive(int width, int height)
{
    MemoryStream original = new MemoryStream
       (System.IO.File.ReadAllBytes(Request.MapPath("~/content/original.jpg")));
    MemoryStream result = new MemoryStream();

    Image image = Image.FromStream(original);

    // Don't do this to yourself!
    Image thumbnail = image.GetThumbnailImage(width, height, null, IntPtr.Zero);
    thumbnail.Save(result, image.RawFormat);

    thumbnail.Dispose();
    image.Dispose();

    result.Position = 0;

    return new FileStreamResult(result, "image/jpeg");
}

Of course, the output is as good as the efforts that you put into writing this code!

Medium Quality

An improved version provides a higher-quality that is more acceptable than the naïve approach. This version uses the Graphics objects along with a Rectangle object and applies InterpolationMode, SmoothingMode, PixelOffsetMode, CompositionQuality properties of the Graphics object to set the quality.

public ActionResult Medium(int width, int height)
{
    MemoryStream original = new MemoryStream
        (System.IO.File.ReadAllBytes(Request.MapPath("~/content/original.jpg")));
    MemoryStream result = new MemoryStream();

    Image image = Image.FromStream(original);
    Bitmap bitmap = new Bitmap(width, height);

    Graphics graphics = Graphics.FromImage(bitmap);
    graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
    graphics.SmoothingMode = SmoothingMode.HighQuality;
    graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
    graphics.CompositingQuality = CompositingQuality.HighQuality;

    Rectangle imageRectangle = new Rectangle(0, 0, width, height);
    graphics.DrawImage(image, imageRectangle);

    bitmap.Save(result, image.RawFormat);

    graphics.Dispose();
    bitmap.Dispose();
    image.Dispose();

    result.Position = 0;

    return new FileStreamResult(result, "image/jpeg");
}

This improves the quality to some extent but it’s not very noticeable.

High Quality

But the improved technique that produces very high quality resized images applies an ImageCodecInfo to use encoders to store the image in a very high quality.

public ActionResult High(int width, int height)
{
    MemoryStream original = new MemoryStream
        (System.IO.File.ReadAllBytes(Request.MapPath("~/content/original.jpg")));
    MemoryStream result = new MemoryStream();

    Image image = Image.FromStream(original);
    Image thumbnail = new Bitmap(width, height);
    Graphics graphics = Graphics.FromImage(thumbnail);

    graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
    graphics.SmoothingMode = SmoothingMode.HighQuality;
    graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
    graphics.CompositingQuality = CompositingQuality.HighQuality;

    graphics.DrawImage(image, 0, 0, width, height);

    ImageCodecInfo[] info = ImageCodecInfo.GetImageEncoders();
    EncoderParameters encoderParameters;
    encoderParameters = new EncoderParameters(1);
    encoderParameters.Param[0] = new EncoderParameter(Encoder.Quality, 100L);

    thumbnail.Save(result, info[1], encoderParameters);

    result.Position = 0;

    return new FileStreamResult(result, "image/jpeg");
}

Here there are some similarities with the last technique and the main difference comes from the way the resized image is saved using an ImageCodecInfo array. I think the details are self-explanatory, so I don’t explain them here.

This technique renders a very high quality resized image that is similar to what you get from image editing programs.

Summary

In a classic post I reinvented the wheel to address the common problem of image resizing in .NET by aiming at producing very high quality images that you can get from photo editing software.

I implemented three different techniques for image resizing in an ASP.NET MVC application starting with a very basic and native approach, followed by an approach that produces medium quality images, and finally a technique that provides very high quality images by using image encoders to save the resized image.

I’ve uploaded the source code sample of this post, so you can download and test all the three techniques yourself.