{"id":4500,"date":"2021-05-13T17:09:40","date_gmt":"2021-05-13T21:09:40","guid":{"rendered":"https:\/\/blogs.mathworks.com\/steve\/?p=4500"},"modified":"2021-05-13T17:19:54","modified_gmt":"2021-05-13T21:19:54","slug":"how-to-use-a-custom-interpolation-kernel-with-imresize","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/steve\/2021\/05\/13\/how-to-use-a-custom-interpolation-kernel-with-imresize\/","title":{"rendered":"How to Use a Custom Interpolation Kernel with imresize"},"content":{"rendered":"
Recently, I was talking with MathWorks writer Jessica Bernier about the <\/span>reference page for the imresize function<\/span><\/a>. Jessica pointed out that we don't have an example that shows how to use your own interpolation kernel. In today's post, I'll compare the supported interpolation kernels on a sample image, and then I'll show you how to use your own kernel.<\/span><\/div>
The different methods supported by <\/span>imresize<\/span>, including <\/span>'bilinear'<\/span>, <\/span>'bicubic'<\/span>, <\/span>'lanczos2'<\/span>, and <\/span>'lanczos3'<\/span>, correspond to using different <\/span>interpolation kernels<\/span>, also known as <\/span>interpolants.<\/span> The bilinear method uses a triangular interpolation kernel, which is defined as:<\/span><\/div>
f<\/mi>(<\/mo>x<\/mi><\/mrow>)<\/mo><\/mrow>=<\/mo>{<\/mo>1<\/mn>-<\/mo>|<\/mo>x<\/mi><\/mrow>|<\/mo><\/mrow><\/mrow><\/mtd>|<\/mo>x<\/mi><\/mrow>|<\/mo><\/mrow>\u2264<\/mo>1<\/mn><\/mrow><\/mtd><\/mtr>0<\/mn><\/mrow><\/mtd>otherwise<\/mi><\/mrow><\/mtd><\/mtr><\/mtable><\/mrow><\/mrow><\/math><\/span><\/div>
fplot(@triangle,[-3.5 3.5])<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
(The function <\/span>triangle<\/span>, as well as the other interpolation kernel functions used in this post, are at the end.)<\/span><\/div>
The bicubic method uses this piecewise cubic interpolation kernel:<\/span><\/div>
f<\/mi>(<\/mo>x<\/mi><\/mrow>)<\/mo><\/mrow>=<\/mo>{<\/mo>1<\/mn>.<\/mo>5<\/mn>|<\/mo>x<\/mi><\/mrow>|<\/mo><\/mrow><\/mrow>3<\/mn><\/mrow><\/msup>-<\/mo>2<\/mn>.<\/mo>5<\/mn>|<\/mo>x<\/mi><\/mrow>|<\/mo><\/mrow><\/mrow>2<\/mn><\/mrow><\/msup>+<\/mo>1<\/mn><\/mrow><\/mtd>|<\/mo>x<\/mi><\/mrow>|<\/mo><\/mrow>\u2264<\/mo>1<\/mn><\/mrow><\/mtd><\/mtr>-<\/mo>0<\/mn>.<\/mo>5<\/mn>|<\/mo>x<\/mi><\/mrow>|<\/mo><\/mrow><\/mrow>3<\/mn><\/mrow><\/msup>+<\/mo>2<\/mn>.<\/mo>5<\/mn>|<\/mo>x<\/mi><\/mrow>|<\/mo><\/mrow><\/mrow>2<\/mn><\/mrow><\/msup>-<\/mo>4<\/mn>|<\/mo>x<\/mi><\/mrow>|<\/mo><\/mrow>+<\/mo>2<\/mn><\/mrow><\/mtd>1<\/mn>\u2264<\/mo>|<\/mo>x<\/mi><\/mrow>|<\/mo><\/mrow>\u2264<\/mo>2<\/mn><\/mrow><\/mtd><\/mtr>0<\/mn><\/mrow><\/mtd>otherwise<\/mi><\/mrow><\/mtd><\/mtr><\/mtable><\/mrow><\/mrow><\/math><\/span><\/div>
fplot(@cubic,[-3.5 3.5])<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
The lanczos2 and lanczos3 methods are based on the <\/span>Lanczos family of interpolation kernels<\/span><\/a>, which are defined as follows (with <\/span>a<\/mi>=<\/mo>2<\/mn><\/mrow><\/math><\/span> or <\/span>a<\/mi>=<\/mo>3<\/mn><\/mrow><\/math><\/span>):<\/span><\/div>
f<\/mi>(<\/mo>x<\/mi><\/mrow>)<\/mo><\/mrow>=<\/mo>{<\/mo>sinc<\/mi>(<\/mo>x<\/mi><\/mrow>)<\/mo><\/mrow>sinc<\/mi>(<\/mo>x<\/mi>\/<\/mo>a<\/mi><\/mrow>)<\/mo><\/mrow><\/mrow><\/mtd>|<\/mo>x<\/mi>|<\/mo>\u2264<\/mo>a<\/mi><\/mrow><\/mtd><\/mtr>0<\/mn><\/mrow><\/mtd>otherwise<\/mi><\/mrow><\/mtd><\/mtr><\/mtable><\/mrow><\/mrow><\/math><\/span><\/div>
lanczos2 = @(x) lanczos(x,2);<\/span><\/span><\/div><\/div>
lanczos3 = @(x) lanczos(x,3);<\/span><\/span><\/div><\/div>
fplot(lanczos2,[-3.5 3.5])<\/span><\/span><\/div><\/div>
hold <\/span>on<\/span><\/span><\/div><\/div>
fplot(lanczos3,[-3.5 3.5])<\/span><\/span><\/div><\/div>
hold <\/span>off<\/span><\/span><\/div><\/div>
legend([<\/span>\"Lanczos 2\"<\/span>, <\/span>\"Lanczos 3\"<\/span>])<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
Interpolation kernels are often tested and compared by resizing a very small image to be several times larger. Here is a small icon image:<\/span><\/div>
image_url = <\/span>\"https:\/\/blogs.mathworks.com\/steve\/files\/region-analyzer-icon.png\"<\/span>;<\/span><\/span><\/div><\/div>
A = imread(image_url);<\/span><\/span><\/div><\/div>
imshow(A,<\/span>\"InitialMagnification\"<\/span>,100)<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
Let's scale this image up by a factor of 10 using the various interpolation methods and compare the results.<\/span><\/div>
B_nearest = imresize(A,10,<\/span>'nearest'<\/span>);<\/span><\/span><\/div><\/div>
B_bilinear = imresize(A,10,<\/span>'bilinear'<\/span>);<\/span><\/span><\/div><\/div>
B_bicubic = imresize(A,10,<\/span>'bicubic'<\/span>);<\/span><\/span><\/div><\/div>
B_lanczos2 = imresize(A,10,<\/span>'lanczos2'<\/span>);<\/span><\/span><\/div><\/div>
B_lanczos3 = imresize(A,10,<\/span>'lanczos3'<\/span>);<\/span><\/span><\/div><\/div>
<\/div><\/div>
montage({B_nearest, B_bilinear, B_bicubic, B_lanczos2, B_lanczos3},<\/span>...<\/span><\/span><\/div><\/div>
<\/span>\"BackgroundColor\"<\/span>,<\/span>\"white\"<\/span>)<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
The nearest-neighbor result, at the upper left, appears quite blocky. In the early years of the Image Processing Toolbox, bilinear (the upper middle result) was the default method. It is better in most respects than the nearest-neighbor result, but it does look a little blurry.<\/span><\/div>
The bicubic result (upper right) and lanczos2 result (lower left) appear very similar. Both interpolation kernels have a nonzero width of 4 (from <\/span>x<\/mi>=<\/mo>-<\/mo>2<\/mn><\/mrow><\/math><\/span> to <\/span>x<\/mi>=<\/mo>2<\/mn><\/mrow><\/math><\/span>) and have one negative side lobe on each side. These results are sharper than the bilinear result. For example, look closely at the digits \"3\" and \"8\" near the top of the image.<\/span><\/div>
The lanczos3 kernel has a nonzero width of 6, with a negative and positive lobe on each side. The lanczos3 result (lower middle) is sharper than the bicubic and lanczos2 results, but it suffers from a visible \"ringing\" effect. You can see this by looking for the faint echo outside the gray boundary, or by looking just to the left and right of the thick black stripe running down the middle of the image.<\/span><\/div>
For this image, I prefer the bicubic method (today's <\/span>imresize<\/span> default) or the lanczos2 method.<\/span><\/div>
There have been a variety of research experiments with different types of interpolation kernels for image processing. For example, a paper by Min Hu and Jieqing Tan (\"Adaptive Osculatory Rational Interpolation for Image Processing,\" <\/span>Journal of Computational and Applied Mathematics<\/span> 195 (2006) 46-53) explores the use of a piecewise rational function:<\/span><\/div>
f<\/mi>(<\/mo>x<\/mi><\/mrow>)<\/mo><\/mrow>=<\/mo>{<\/mo>-<\/mo>0<\/mn>.<\/mo>168<\/mn>|<\/mo>x<\/mi>|<\/mo><\/mrow>2<\/mn><\/mrow><\/msup>-<\/mo>0<\/mn>.<\/mo>9129<\/mn>|<\/mo>x<\/mi>|<\/mo>+<\/mo>1<\/mn>.<\/mo>0808<\/mn><\/mrow>|<\/mo>x<\/mi>|<\/mo><\/mrow>2<\/mn><\/mrow><\/msup>-<\/mo>0<\/mn>.<\/mo>8319<\/mn>|<\/mo>x<\/mi>|<\/mo>+<\/mo>1<\/mn>.<\/mo>0808<\/mn><\/mrow><\/mfrac><\/mrow><\/mtd>|<\/mo>x<\/mi>|<\/mo>\u2264<\/mo>1<\/mn><\/mrow><\/mtd><\/mtr>0<\/mn>.<\/mo>1953<\/mn>|<\/mo>x<\/mi>|<\/mo><\/mrow>2<\/mn><\/mrow><\/msup>-<\/mo>0<\/mn>.<\/mo>5858<\/mn>|<\/mo>x<\/mi>|<\/mo>+<\/mo>0<\/mn>.<\/mo>3905<\/mn><\/mrow>|<\/mo>x<\/mi>|<\/mo><\/mrow>2<\/mn><\/mrow><\/msup>-<\/mo>2<\/mn>.<\/mo>4402<\/mn>|<\/mo>x<\/mi>|<\/mo>+<\/mo>1<\/mn>.<\/mo>7676<\/mn><\/mrow><\/mfrac><\/mrow><\/mtd>1<\/mn><<\/mo>|<\/mo>x<\/mi>|<\/mo>\u2264<\/mo>2<\/mn><\/mrow><\/mtd><\/mtr>0<\/mn><\/mrow><\/mtd>2<\/mn><<\/mo>|<\/mo>x<\/mi>|<\/mo><\/mrow><\/mtd><\/mtr><\/mtable><\/mrow><\/mrow><\/math><\/span><\/div>
Here's what that looks like:<\/span><\/div>
fplot(@osc,[-3.5 3.5])<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
To resize the image using this kernel, specify the function handle and the nonzero kernel width (4, in this case) as the method for <\/span>imresize<\/span>:<\/span><\/div>
B_osc = imresize(A,10,{@osc,4});<\/span><\/span><\/div><\/div><\/div>
Now compare this result with the others.<\/span><\/div>
montage({B_nearest, B_bilinear, B_bicubic, B_lanczos2, B_lanczos3, B_osc},<\/span>...<\/span><\/span><\/div><\/div>
<\/span>\"BackgroundColor\"<\/span>,<\/span>\"white\"<\/span>)<\/span><\/span><\/div>
<\/div><\/div><\/div><\/div><\/div>
To my eye, this newer interpolation kernel produces the best result of the bunch. It is slightly sharper than the bicubic and lanczos2 results, with slightly smoother diagonal edges, but without the ringing of the lanczos3 result. Fully assessing the performance of this kernel, though, would require examining a variety of different images and scale factors.<\/span><\/div>
Have you ever used a custom interpolation kernel with <\/span>imresize<\/span>? What did you use? Leave a comment and let us know.<\/span><\/div>
Thanks, Jessica, for prompting me to look at this.<\/span><\/div>
function <\/span>f = triangle(x)<\/span><\/span><\/div><\/div>
f = (1 - abs(x)) .* (abs(x) <= 1);<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
<\/div><\/div>
function <\/span>f = cubic(x)<\/span><\/span><\/div><\/div>
absx = abs(x);<\/span><\/span><\/div><\/div>
absx2 = absx.^2;<\/span><\/span><\/div><\/div>
absx3 = absx.^3;<\/span><\/span><\/div><\/div>
<\/div><\/div>
f = (1.5*absx3 - 2.5*absx2 + 1) .* (absx <= 1) + <\/span>...<\/span><\/span><\/div><\/div>
(-0.5*absx3 + 2.5*absx2 - 4*absx + 2) .* <\/span>...<\/span><\/span><\/div><\/div>
((1 < absx) & (absx <= 2));<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
<\/div><\/div>
function <\/span>f = lanczos(x,a)<\/span><\/span><\/div><\/div>
f = a*sin(pi*x) .* sin(pi*x\/a) .\/ <\/span>...<\/span><\/span><\/div><\/div>
(pi^2 * x.^2);<\/span><\/span><\/div><\/div>
f(abs(x) > a) = 0;<\/span><\/span><\/div><\/div>
f(x == 0) = 1;<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
<\/div><\/div>
function <\/span>f = osc(x)<\/span><\/span><\/div><\/div>
absx = abs(x);<\/span><\/span><\/div><\/div>
absx2 = absx.^2;<\/span><\/span><\/div><\/div>
<\/div><\/div>
f = (absx <= 1) .* <\/span>...<\/span><\/span><\/div><\/div>
((-0.168*absx2 - 0.9129*absx + 1.0808) .\/ (absx2 - 0.8319*absx + 1.0808)) <\/span>...<\/span><\/span><\/div><\/div>
+ <\/span>...<\/span><\/span><\/div><\/div>
((1 < absx) & (absx <= 2)) .* <\/span>...<\/span><\/span><\/div><\/div>
((0.1953*absx2 - 0.5858*absx + 0.3905) .\/ (absx2 - 2.4402*absx + 1.7676));<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div><\/div>\r\n<\/div>