Click here to Skip to main content
Click here to Skip to main content
Go to top

Image Resizing - outperform GDI+

, 16 Aug 2007
Rate this:
Please Sign up or sign in to vote.
This article discusses a little weakness in GDI+ filters and shows a class for top-quality image resizing.


Even the GDI+ methods aren't the most comprehensive. A commonly used image resizing methods are e.g. Nearest Neighbor, Bilinear or Bicubic. These are part of some "standard", but experts and freaks know that these filters doesn't provide as nice images as other filters can. In some software products (especially specialized software for astronomical and medical imaging), we can see filters with strange names like Hermite, Mitchell or Lanczos. These filters works with reference to image's frequency spectra or edges. One of the most unpleasant artifacts is the Moiré effect which can appear while scaling detailed image down. In order to prevent these artifacts, enhance edges and reduce pixelation - more complex filters were designed.

In spite of GDI+, filters have big problems with Moiré patterns, they make some artifacts on image borders (it's not an error and can be eliminated, as will be discussed later). This article presents class for image resampling with more precise filters.


The first mentoined artifact was the Moiré pattern which appears due to aliasing. This artifact can be seen when one shrinks images without blurring image before zooming, so the high frequencies in the image create a pattern. Samples taken from old images create new frequencies in the new image. This effect is most visible when using a filter with low radius (this filter includes too few adjacent pixels around sample from old image). These examples shows the aliasing artifact produced by a so called Nearest Neighbor filter (first image from left).

Much better quality can be obtained by using the GDI+ Low filter (second image - filter has radius 1). Even better quality is provided by the High Quality Bicubic filter (radius 2). Finally, there is the image output from filtering via Lanczos8 filter (radius 8) from the ResamplingService class. This filter has three times larger radius, so it provides highest quality image from these filters (roof tiles are more visible and sharper):

Screenshot - moire_nn.gifScreenshot - moire_low.gifScreenshot - moire_hqbic.gifScreenshot - moire_lanc.gif

The original roof image can be found in Wikipedia in the "Moiré pattern" article. It's hard to see, but that last image is sharper than the third one, but there is other more visible defect in the GDI+ resampled version:

Screenshot - defect.gif Screenshot - nodefect.gif

This problem can be easily solved using the ImageAttributes object in DrawImage method override (don't forget to dispose it):

System.Drawing.Imaging.ImageAttributes attr = 
    new System.Drawing.Imaging.ImageAttributes();


An alternative solution is to set the PixelOffsetMode property of the Graphics object to an appropriate value:

Graphics grfx = Graphics.FromImage(imgInput);

grfx.PixelOffsetMode = PixelOffsetMode.HighQuality;

Image Resampling with GDI+ Filters

Image resizing (or resampling) is one of the most common functions of every raster image processing tool. If you've decided for GDI+ to resize your images, you can choose from variety of filters. So called Nearest Neighbor (System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor) filter is the fastest one, but it produces blocky artifacts on image stretching because this filter just copies samples from old image to a new image (no interpolation between them). On the contrary, when downsampling by factor 2, every second pixel is lost:

Screenshot - downsample_nearest_neighbor.gifScreenshot - original.gif Screenshot - upsample_nearest_neighbor.gif

Much better results can be achieved using some interpolation spline. When the image is scaled up, a space between pixels must be filled with some new pixel values. Value of the new pixel can be computed as weighted average of nearest pixel and its neighbors (weights are given by the filter). One of the simplest interpolation/resampling filter is Linear filter (InterpolationMode.Low). The weight of neighboring pixels is a linear function. If you want achieve the "best" quality, then use High Quality Bicubic (InterpolationMode.HighQualityBicubic). This interpolation includes more neighbors in every new pixel value and weights are distributed more effectively (the function is a cubic spline):

Screenshot - downsample_bicubic_gdi.gifScreenshot - original.gif Screenshot - upsample_bicubic_gdi.gif

The interpolation of the scaled image is done by image filtering, or convolution between image (intensity function) and convolution kernel. If you want closer explanation of how convolution works, see one of the excellent articles from Christian Grauss at this site. He also explains bilinear interpolation.

Image Resampling with Custom Filters

Now point our view to ResamplingService.cs. This code file contains few classes for precise resampling. The most important class is ResamplingService, whose method provides all the functionality.

There is one class representing common resampling filter:

public abstract class ResamplingFilter

When you run the resampling, a new instance of ResamplingFilter is created as well. The filter depends on the Filter property of the ResamplingService object.

A few people mentioned the fact that older version of this library could not resample images with alpha channel. So I've made it much more versatile after this feedback, primarily by using the ushort array (except GDI+ Bitmap). Benefits of this approach are listed below. To resample a GDI+ Bitmap, one must add some functionality to provide conversion between Bitmap and ushort[][,] types (the conversion routines are made for 32 bits per pixel with alpha, but can be easily extended to support arbitrary color formats).

Resampling using ResamplingService has a disadvantage in speed (it's not real-time), but you'll obtain fine results:

Screenshot - downsample_cc.gif Screenshot - original.gif Screenshot - upsample_cc.gif

In the extreme case, we can compare results on upsampling four times. The results are obtained using GDI+ HQ Bicubic filter (left), Paint Shop PRO 8 Smart Size (middle) and current implementation of Lanczos8 filter:

Screenshot - extreme_gdi.gif Screenshot - extreme_psp.gif Screenshot - extreme_lanc.gif

About the Filters

I've implemented a collection of different resampling filters. Some of them provide even better results than filters in professional imaging applications. ResamplingService supports these filters (you can add your own filter by inheriting the ResamplingFilter class and adding new filter creation in the Create method of the base class). Here is the brief description of ResamplingFilters enumeration members:

Box equivalent to Nearest Neighbor on upsampling, averages pixels on downsampling
Triangle equivalent to Low; the function can be called Tent function for its shape
Hermite use of the cubic spline from Hermite interpolation
Bell attempt to compromise between reducing block artifacts and blurring image
CubicBSpline most blurry filter (cubic Bezier spline) - known samples are just "magnets" for this curve
Lanczos3 windowed Sinc function (sin(x)/x) - promising quality, but ringing artifacts can appear
Mitchell another compromise, but excellent for upsampling
Cosine an attemp to replace curve of high order polynomial by cosine function (which is even)
CatmullRom Catmull-Rom curve, used in first image warping algorithm (did you see Terminator II ?)
Quadratic performance optimized filter - results are like with B-Splines, but using quadratic function only
QuadraticBSpline quadratic Bezier spline modification
CubicConvolution filter used in one example, its weight distribution enhances image edges
Lanczos8 also Sinc function, but with larger window, this function includes largest neighborhood

Using the Code

The project demo solution is extremely simple to understand. All you have to do is to use ResamplingService in your own project by copying ResamplingService.cs into your project directory and start using this with a few lines of code:

ResamplingService resamplingService = new ResamplingService();

resamplingService.Filter = ResamplingFilters.CubicBSpline;

ushort[][,] input = ConvertBitmapToArray((Bitmap)imgInput);

ushort[][,] output = resamplingService.Resample(input, nSize.Width, 

Image imgCustom = (Image)ConvertArrayToBitmap(output);

This code will create a ResamplingService instance, sets its Filter property such that it will use the CubicBSpline filter, converts the input image to array, resamples the array bitmap into a new array, and finally converts the output array to image. Note that conversion methods in the sample code works only with bitmaps whose pixel format is 32bpp with alpha (4 planes).

Beyond Conventional Methods

None of the presented filters (GDI+ or other) can preserve edges, add artifcial detail or do something more on image. Somebody can ask: "And what about that expensive zooming software, that uses edge-enhancing diffusion, adaptive splines or fractals to achieve good visual quality?"

The truth is, that these technologies are licensed, but not unknown. Everyone can design some adaptive filter (actual kernel depends on current pixel neighborhood). But these filters are too slow for real-time applications (TV, DVD, games, ...). Yes, of course, it's very practical for photographers. They preserve quality before performance.

I'm not familiar with spline approaches, but I've done some investigation on fractals, because it can be used to add good-looking detail into natural images, not only keep image edges. This samples were made by using nontrivial fractal resolution enhancement technique:

Screenshot - original.gif Screenshot - upsample_fractal1.gif Screenshot - upsample_fractal2.gif

Many students on my faculty are interested in digital photography, so the fractal library will be freely available for academic purposes. This is a better choice than very expensive professional zooming software on the market. The only only difference between academic version and the professional is the ratio between quality and speed. PRO software is quick with compromise results, the scientific approach needs to sacrifice tens of minutes to zoom an average-sized image, but the quality gain is sensible (here in 400% zoom)...

Original crop of the wood in fall image:

Screenshot - fall_original.jpg

Photoshop's Bicubic filter:

Screenshot - fall_Photoshop.jpg

Genuine Fractals PrintPro - top zooming software available:

Screenshot - fall_GF.jpg

Our implementation of fractal-based zooming:

Screenshot - fall_ImagingShop.jpg


I hope you've got a brief look onto the resampling topic. We discussed a way how to work with your own filters. To get more information, try to look for some technical articles. You can find several other implementations of resampling methods, but be careful about its properties. I tested my class for many grotesque image sizes (like 1x2397 from 191x2 pixels) and eliminated all artifacts on edges, repairing wrong weight distributions I saw in other sources.

One programmer showed me his GUI specialized on resampling. I've discovered and removed a terrible problem, which was causing black and white stripes over all images when reducing its size by an odd factor - of course due to the wrong weight distribution. This was a week before his resampling app became commercial component. I think the presented class is OK, but if you find anything or if you have any ideas how to optimize this common filtering algorithm, I'll be happy to discuss it.

Changes in the Last Version

The code was modified and made more readable (more private access modifiers, global variables reduced, more blank lines, indentation and XML comments). The library works with ushort[][,] except Bitmap. Why ushort[][,] and why not something else like byte[,]? I've chosen this type because it can contain a bitmap with almost any thinkable color format (from black&white image to 16-bit per channel image plus alpha) and all the color formats can be handled the same way. The jagged array of ushort (ushort range is four bytes or 0-65535) can contain any number of planes. The reason for jagged array except only ushort[,] is that the resampling procedure precomputes pixel weights and then filters every plane with same weights, so this solution gives better performance on color images. The code is now 100% managed (no unsafe code blocks). The way the library is used was also changed and the filters were enumerated to be more transparent.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Libor Tinka
Software Developer
Czech Republic Czech Republic
Founder of two companies focusing on digital imaging, computer vision and .NET components.
Currently focuses on Image alignment and stitching library for .NET, software consulting and .NET component development.
He loves digital photography, programming, yoga, math, comics drawing, healthy lifestyle and green tea.

Comments and Discussions

GeneralHelp with aplha PinmemberFabian von Romberg13-Aug-07 21:02 
GeneralRe: Help with aplha PinmemberLibor Tinka14-Aug-07 12:02 
GeneralRe: Help with aplha PinmemberFabian von Romberg14-Aug-07 18:24 
GeneralRe: Help with aplha PinmemberLibor Tinka16-Aug-07 15:41 
GeneralRe: Help with aplha Pinmemberjeffpowers14-Sep-07 15:58 
GeneralRe: Help with aplha Pinmemberjeffpowers14-Sep-07 16:09 
GeneralRe: Help with aplha Pinmemberrobertjb2011-Jan-09 6:42 
GeneralRe: Help with aplha PinmemberLibor Tinka12-Jan-09 5:55 
GeneralLicense Pinmembersebseb5129-Apr-07 3:27 
GeneralRe: License PinmemberLibor Tinka30-Apr-07 5:35 
QuestionWhat about downsampling? Pinmemberawa0626-Oct-06 17:25 
AnswerRe: What about downsampling? PinmemberLibor Tinka27-Oct-06 10:58 
QuestionMay you provide the detail algorithm? PinmemberLiming Hu24-Jun-06 6:26 
AnswerRe: May you provide the detail algorithm? PinmemberLibor Tinka27-Oct-06 10:52 
The algorithm is same for all the filters. As you can see in the code, the ResamplingFilter class is abstract. All the work is done by filtering, i.e. convolution by the specific kernel (filter). Filters varies by its size and base function (cubic, sinc ...).
JokeNice work! PinmemberJDBP16-Apr-06 19:42 
GeneralRe: Nice work! Pinmemberltinka18-Apr-06 1:58 
GeneralLoss of DPI Pinmembersides_dale5-Apr-06 17:59 
GeneralRe: Loss of DPI Pinmemberltinka6-Apr-06 0:56 
GeneralGDI+ - precise scale problem Pinmemberalexiev_nikolay3-Apr-06 9:37 
GeneralRe: GDI+ - precise scale problem Pinmemberltinka4-Apr-06 7:02 
GeneralRe: GDI+ - precise scale problem Pinmemberalexiev_nikolay4-Apr-06 8:43 
GeneralRe: GDI+ - precise scale problem Pinmemberltinka4-Apr-06 12:09 
GeneralRe: GDI+ - precise scale problem Pinmemberalexiev_nikolay5-Apr-06 7:19 
GeneralQImage / Pyramid Splines Etc. PinmemberTODDIDPA22-Mar-06 15:57 
GeneralRe: QImage / Pyramid Splines Etc. Pinmemberltinka23-Mar-06 4:27 
GeneralRe: QImage / Pyramid Splines Etc. PinmemberTODDIDPA23-Mar-06 7:30 
GeneralRe: QImage / Pyramid Splines Etc. Pinmemberltinka30-Mar-06 11:50 
QuestionNice work! But what about the filters? Pinmemberthany5-Feb-06 4:20 
AnswerRe: Nice work! But what about the filters? Pinmemberltinka5-Feb-06 8:26 
QuestionImpressive. Required files for GDI+? PinmemberMr_Analogy1-Feb-06 21:35 
AnswerRe: Impressive. Required files for GDI+? Pinmemberltinka2-Feb-06 0:44 
AnswerRe: Impressive. Required files for GDI+? PinmemberLibor Tinka14-Aug-07 12:08 
GeneralFaststone Pinmemberronenjinji23-Jan-06 4:23 
GeneralRe: Faststone Pinmemberronenjinji23-Jan-06 4:45 
GeneralRe: Faststone Pinmemberronenjinji23-Jan-06 6:00 
GeneralRe: Faststone Pinmemberltinka23-Jan-06 10:59 
GeneralRe: Faststone Pinmemberronenjinji23-Jan-06 20:48 
GeneralRe: Faststone Pinmemberltinka23-Jan-06 21:45 
GeneralRe: Faststone Pinmemberronenjinji24-Jan-06 0:26 
GeneralRe: Faststone Pinmemberltinka25-Jan-06 5:08 
GeneralRe: Faststone Pinmemberronenjinji25-Jan-06 6:41 
GeneralRe: Faststone Pinmemberltinka25-Jan-06 9:29 
GeneralRe: Faststone Pinmemberronenjinji29-Jan-06 4:01 
Generalnull pointer on filter Pinmemberpostma13-Nov-05 5:20 
QuestionWhat about alpha channel??? Pinmembermisxa26-Oct-05 0:03 
AnswerRe: What about alpha channel??? Pinmemberltinka26-Oct-05 1:32 
GeneralRe: What about alpha channel??? Pinmembermisxa27-Oct-05 1:06 
GeneralBlack line no more! PinmemberMichael Mondry20-Sep-05 12:40 
GeneralRe: Black line no more! Pinmemberltinka21-Sep-05 9:08 
GeneralRe: Black line no more! Pinmemberdshill9926-Feb-06 18:42 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web01 | 2.8.140916.1 | Last Updated 16 Aug 2007
Article Copyright 2005 by Libor Tinka
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid