Image interpolation algorithms

Well I'll have ago seeing as no one else is! Heres my code to get an interpolated pixel value from an image:


Heres the code for the resizing (I use FreeImage myself, so this code is off the top of my head):



I am pretty sure this is NOT optimal for image minification (because source pixels will be skipped, instead of averaged), but should be good for magnification. Maybe this will give you a good start though.
To change the interpolation type just adjust the Interpolate() function. I think bicubic uses a 16 pixel sampling area, linear a 4 pixel one (like the current function). Not sure about spline interpolation, but hermite code is pretty easy to find.
HTH

Thanks... I appreciate very much your replies... The network is a great place where "live" smart and kind people... Bye!

For downscaling to a factor of 50% or less, the best algorithm IME is a box averaging filter - you just average all the filters in a M*N box where M is the factor of vertical reduction and N is the horizontal. For example, to reduce an image to 1/3 of it's original size, you just average the pixels in a 3x3 box for each pixel in the smaller image.
For factors between 100% and 50%, other algorithms will sometimes produce better results.

From a technical point of view, scaling an image is a process of a 2D re-sampling. If zooming in, you want to do a net "super-sampling" (or "up sampling"), else a net "sub-sampling" (or "down sampling"). I said "net" here since mixed forms may be used for fractional scale factors.

You may try to search for these terms in the internet. In all cases there is the need of filtering, e.g. to avoid alias in the case of sub-sampling, to do it right. Which filter to use is just a question of quality you want to yield. E.g. the mentioned interpolators named in the original post by alexandro_81 are in fact such filters.

For very high quality scale ups (or very high scale factors), methods exist that perform some feature recognition and enhancement, e.g. sharpening of edges. But may be such things are out of range of what you want.

Again on bicubic interpolation...

I found this Delphi-like procedure:

Function Bicubic ( x,y: real) : byte
var j,k: integer;
var a,b: real;
var dest: real;
var ti,t2,t3,t4: real;

Begin
j := round(x);
k := round(y);

a := x - j;
b := y - k;

t1 := -a* (1-a)*Pixel[j-1,k-1]+
(1-2*a*a+a*a*a)* Pixel[j,k-1] +
a*(1+a-a*a)*Pixel[j+1,k-1] -
a*a*(1-a)*Pixel[j+2,k-1]

t2 := -a* (1-a)*Pixel[j-1,k]+
(1-2*a*a+a*a*a)* Pixel[j,k] +
a*(1+a-a*a)*Pixel[j+1,k] -
a*a*(1-a)*Pixel[j+2,k]

t3 := -a* (1-a)*Pixel[j-1,k+1]+
(1-2*a*a+a*a*a)* Pixel[j,k+1] +
a*(1+a-a*a)*Pixel[j+1,k+1] -
a*a*(1-a)*Pixel[j+2,k+1]

t4 := -a* (1-a)*Pixel[j-1,k+2]+
(1-2*a*a+a*a*a)* Pixel[j,k+2] +
a*(1+a-a*a)*Pixel[j+1,k+2] -
a*a*(1-a)*Pixel[j+2,k+2]

pixel := -b* (1-b)*t1 +
(1-2*b*b+b*b*b)* t2 +
b*(1+b-b*b)* t3 -
b*b*(1-b)*t4
end


I can't why the weights of the average are calculated in that way? does anybody know it?

Hello,
Since you are interested in the subject: Aramini's paper is one of the simpler bicubic resampling algorithm I found on the net (mostly because it cut the problem in smaller pieces using bicbic splines, and because the math is simple enough :D). The code is somewhat simple to write, and it can be easily (and heavily) optimized.

HTH,